TF2 Item Format

Formatting for TF2 items.

Install it via npm install tf2-item-format

Features

- Parses item name into attribute object
- Stringifies attribute object into item name same as backpack.tf
- Parses ECON item into attributes
- Parses SKU into attributes
- Makes SKU out of attributes
- Creates backpack.tf compatible format for listing creation

Support the project

tf2-item-format is now used in number of production grade projects for handling item data,
help support the project by donating items here.

$3

To inject your own schema use this interface:

``ts
export type ISchema = {
getDefindex(search: number | string): number | null;
getName(search: number | string): string;
getEffectName(effect: number | string): string;
getWearName(wear: number | string): string;
getKillstreakName(killstreak: number | string): string;
getTextureName(texture: number | string): string;
getQualityName(quality: number | string): string;
getEffectEnum(effect: number | string): number;
getWearEnum(wear: number | string): number;
getKillstreakEnum(killstreak: number | string): number;
getTextureEnum(texture: number | string): number;
getQualityEnum(quality: number | string): number;
getTextures(): SchemaEnum;
getEffects(): SchemaEnum;
isUniqueHat(defindexOrName: string | number): boolean;
getItems(): SchemaItem[]; // Return GetSchemaItems API response
getVersion(): number;
};

// Extra types you might need:
export type NameToDefindex = { [name: string]: number };
export type DefindexToName = { [defindex: number]: string };
export type SchemaEnum = NameToDefindex & DefindexToName;

// Import these like:
// import { ISchema, NameToDefindex, DefindexToName, SchemaEnum } from 'tf2-item-format'
`

Then you just have to:

`ts
import { createFormat } from 'tf2-item-format';

const format = createFormat(schema);
`

Every method is then export same as before.

You can use parseSKU and toSKU without schema:

`ts
import { parseSKU, toSKU } from 'tf2-item-format';
`

Please note that static schema has implemented a lot of overwrites for defindexes that simply cannot be obtained by the limited data we have, so when you are implementing it yourself you should use the current Schema as your guide.

getVersion function should return a versioning number for your schema, we recommend incrementing
this whenever you update your schema, so that cached items, like exceptions for item combinations
that cannot co-exist, can be recalculated. Only do this whenever the schema actually changes,
easiest way to do that, is by checking the item count between updates.

Instalation

Via NPM: npm install tf2-item-format
Or Yarn: yarn add tf2-item-format

Documentation

Currently there is no full documentation.

We export these methods:

- parseString
- stringify
- parseEconItem
- toSKU
- parseSKU
- createBPListing
- fixName

And static schema:

- under property schema

Everything is fully typed so you should be able to get this working on your own, until I make a documentation.
Some of the types are a bit confusing which will get fixed in next major version.

$3

`ts
parseEconItem(econ: EconItem, inNumbers: boolean, useDefindexes: boolean, options?: { useTrueDefindex: boolean }): ParsedEconItem;
`

- econ is raw item you receive from the api
- inNumbers - changes return type of certain attributes to numbers instead of pure strings, eg. quality, texture, wear, ...
- useDefindexes - appends item defindex to the object, adds target & output aswell
- options
- useTrueDefindex - returns true defindex item has on this econ, doesn't ask schema.
- itemNumberFromFraudWarning - retrieve item number (crate series or craft number) from fraudwarning property
- retrieveCrateNumber - if item is a case, retrieve it's case number
- Returns ParsedEconItem which is an object of all attributes the econ gives us

$3

`ts
createBPListing(attributes: ItemAttributes | StringifySKUAttributes, options?: CreateBPListingOptions): BackpackTFListing
`

- attributes - these you get from parseString, parseSKU or parseEconItem, all are compatible
- options
- unuSkinsToDecorated - defaults unusual skins to decorated weapon quality, default value is true
- Returns BackpackTFListing object compatible with item object in backpack.tf listing creation api

$3

`ts
stringify(attributes: StrigifySKUAttributes | ItemAttributes, options?: StringifyOptions): string
`

- attributes - these you get from parseString, parseSKU or parseEconItem, all are compatible
- options
- determineUniqueHat - if set it checks in schema if given item should use The in name, defaults to false
- Returns the item name

> [!INFO]
> If you are using sku format to store your items and want to use The in your names, you have to turn determineUniqueHat to true.

$3

`ts
parseSKU(sku: string): SKUAttributes
`

Parse Marketplace.tf's SKU format into SKUAttributes object, which is compatible with other methods.

$3

`ts
toSKU(attribute: SKUAttributes): string
`

Get an SKU from SKUAttributes object, you can also supply EconItem or attributes from parseString if you have inNumbers and useDefindexes set to true.

Compability usage

`ts
// Have a name, want a sku
const attributes = parseString(name, true, true); // To get defindexes and enums
const sku = toSKU(attributes);

// Have a sku, want a name
const attributes = parseSKU(sku);
const name = stringify(attributes);

// Have a sku, want a bp listing
const attributes = parseSKU(sku);
const listing = createBPListing(attributes);
``

Every method should be interchangable in similar ways.