@juice789/tf2items 1.0.0

package/schemaItems.js

@@ -0,0 +1,15 @@
+const schema = require('./schema.json')
+
+const safeItems = new Proxy(schema.items, {
+    get(receiver, name) {
+        return name in receiver ? receiver[name] : {
+            defindex: name,
+            item_name: 'Undefined item'
+        }
+    }
+})
+
+module.exports = {
+    ...schema,
+    safeItems,
+}

package/sku.js

@@ -0,0 +1,142 @@
+const {
+    compose, split, map, reduce, pickBy, mergeRight, converge, concat, of, join, head, tail, filter
+} = require('ramda')
+
+const {
+    safeItems
+} = require('./schemaItems.js')
+
+const {
+    qualityNames,
+    killstreakTiers,
+    wears
+} = require('./schemaHelper.json')
+
+const {
+    textures,
+    particleEffects
+} = require('./schema.json')
+
+const skuFromItem = ({
+    defindex,
+    quality,
+    uncraftable,
+    elevated,
+    effect,
+    killstreakTier,
+    festivized,
+    target,
+    output,
+    oq,
+    texture,
+    wear,
+    australium,
+    series,
+    craft
+}) => [
+    defindex,
+    quality,
+    ['1', true].includes(uncraftable) && 'uncraftable',
+    ['1', true].includes(elevated) && 'strange',
+    effect && 'u-' + effect,
+    killstreakTier && ['1', '2', '3', 1, 2, 3].includes(killstreakTier) && 'kt-' + killstreakTier,
+    ['1', true].includes(festivized) && 'festive',
+    target && 'td-' + target,
+    output && 'od-' + output,
+    oq && 'oq-' + oq,
+    texture && 'pk-' + texture,
+    wear && 'w-' + wear,
+    ['1', true].includes(australium) && 'australium',
+    series && isNaN(series) === false && 'c-' + parseInt(series),
+    craft && isNaN(craft) === false && 'no-' + parseInt(craft),
+].filter(Boolean).join(';')
+
+const rules = {
+    uncraftable: 'uncraftable',
+    strange: 'elevated',
+    u: "effect",
+    kt: "killstreakTier",
+    festive: 'festivized',
+    td: "target",
+    od: "output",
+    oq: "oq",
+    pk: "texture",
+    w: "wear",
+    australium: 'australium',
+    c: "series",
+    no: "craft"
+}
+
+const decodeRules = compose(
+    pickBy((v, k) => k !== 'undefined'),
+    reduce(mergeRight, {}),
+    map(
+        compose(
+            ([k, value = true]) => ({ [rules[k]]: value }),
+            converge(concat, [compose(of, head), compose(filter(Boolean), of, join('-'), tail)]),
+            split('-')
+        )
+    )
+)
+
+const itemFromSku = (sku) => {
+    const [defindex, quality, ...more] = sku.split(';')
+    const item = {
+        defindex,
+        quality,
+        ...decodeRules(more)
+    }
+    item.sku = sku
+    return item
+}
+
+const getName = ({
+    defindex,
+    quality,
+    uncraftable,
+    elevated,
+    effect,
+    killstreakTier,
+    festivized,
+    target,
+    output,
+    oq,
+    texture,
+    wear,
+    australium,
+    series,
+    craft
+},
+    bpTexture = false,
+    qualityBpStyle = false
+) => [
+    craft && '#' + craft,
+    uncraftable && 'Non-Craftable',
+    elevated && 'Strange',
+    quality && !['6', '15'].includes(quality.toString()) && (qualityBpStyle ? effect : true) && qualityNames[quality],
+    oq && oq.toString() !== '6' && qualityNames[oq],
+    target && killstreakTier && killstreakTiers[killstreakTier],
+    target && safeItems[target].item_name,
+    output && safeItems[output].item_name,
+    effect && particleEffects[effect],
+    festivized && 'Festivized',
+    !target && killstreakTier && killstreakTiers[killstreakTier],
+    texture && textures[texture],
+    bpTexture && '|',
+    australium && 'Australium',
+    safeItems[defindex].item_name,
+    wear && '(' + wears[wear] + ')',
+    series && '#' + series
+].filter(Boolean).join(' ')
+
+const itemNameFromSku = (sku) => {
+    const item = itemFromSku(sku)
+    return getName(item)
+}
+
+module.exports = {
+    skuFromItem,
+    itemFromSku,
+    getName,
+    itemNameFromSku
+}

package/skuBp.js

@@ -0,0 +1,87 @@
+const crypto = require('crypto')
+const { safeItems: items } = require('./schemaItems.js')
+const { qualityNames } = require('./schemaHelper.json')
+const { itemFromSku, getName } = require('./sku.js')
+const { omit } = require('ramda')
+
+const toBpQuality = (sku) => {
+
+    const {
+        defindex,
+        quality,
+        effect,
+        elevated,
+        texture,
+    } = itemFromSku(sku)
+
+    const isWeaponEffect = ['701', '702', '703', '704'].includes(effect)
+
+    const isPainted = items[defindex].item_name === 'War Paint' || Boolean(texture) || isWeaponEffect
+
+    return [
+        (elevated || quality === '11' && isPainted) && 'Strange',
+        isPainted
+            ? !elevated && qualityNames[isWeaponEffect ? '5' : '15']
+            : qualityNames[quality]
+    ].filter(Boolean).join(' ')
+}
+
+const toBpName = (sku) => {
+
+    const item = omit(
+        ['quality', 'elevated', 'uncraftable', 'craft', 'target', 'output', 'oq', 'effect'],
+        itemFromSku(sku)
+    )
+
+    return getName(item, Boolean(item.texture)).replace('\\n', '%0A')
+}
+
+const toBpPriceIndex = (sku) => {
+
+    const {
+        effect,
+        killstreakTier,
+        target,
+        output,
+        oq,
+        series
+    } = itemFromSku(sku)
+
+    return [
+        effect,
+        !oq && killstreakTier && target && killstreakTier + '-' + target,//kit
+        output && target && oq && output + '-' + oq + '-' + target,//fabricator, strangifier chemistry set
+        !target && output && oq && output + '-' + oq, //collector's chemistry set
+        !killstreakTier && target && !output && target, //unusualifier
+        series
+    ].filter(Boolean).join('/')
+}
+
+const listingFromSku = (sku) => {
+    const { uncraftable } = itemFromSku(sku)
+    return {
+        quality: toBpQuality(sku),
+        craftable: uncraftable ? '0' : '1',
+        item_name: toBpName(sku),
+        priceindex: toBpPriceIndex(sku)
+    }
+}
+
+const toBpSku = (sku) => {
+    const item = omit(
+        ['craft'],
+        itemFromSku(sku)
+    )
+    return getName(item, null, Boolean(item.effect))
+}
+
+const toBpId = (sku) => crypto.createHash('md5').update(toBpSku(sku)).digest('hex')
+
+module.exports = {
+    toBpQuality,
+    toBpName,
+    toBpId,
+    toBpPriceIndex,
+    listingFromSku,
+    toBpSku
+}

package/toSearchParams.js

@@ -0,0 +1,99 @@
+const {
+    always,
+    prop,
+    ifElse,
+    propEq,
+    compose,
+    defaultTo,
+    __,
+    map,
+    applyTo,
+    complement,
+    allPass,
+    includes
+} = require('ramda')
+
+const { safeItems: items } = require('./schemaItems.js')
+const { textures } = require('./schema.json')
+const { itemFromSku } = require('./sku.js')
+
+//collectors chem sets: output
+//strangifier chem sets, strangifier, unusualifier, kit, fab: target
+
+const item = ({ defindex, target, output }) => items[target || output || defindex].item_name
+
+const quality = ({
+    defindex,
+    quality,
+    effect,
+    texture,
+    elevated
+}) => items[defindex].item_name === 'War Paint' || (Boolean(texture) || ['701', '702', '703', '704'].includes(effect))
+        ? (elevated ? '11' : '5')
+        : quality
+
+const australium = ifElse(
+    propEq('australium', true),
+    always(1),
+    always(-1)
+)
+
+const killstreak_tier = compose(
+    defaultTo(0),
+    prop('killstreakTier')
+)
+
+const craftable = ifElse(
+    propEq('uncraftable', true),
+    always(-1),
+    always(1)
+)
+
+const particle = prop('effect')
+
+const item_type = ({ target, output }) =>
+    target
+        ? 'target'
+        : output
+            ? 'output'
+            : undefined
+
+const wear_tier = prop('wear')
+
+const texture_name = compose(prop(__, textures), prop('texture'))
+
+const elevated = ifElse(
+    allPass([
+        propEq('elevated', true),
+        compose(
+            complement(includes)(__, ['701', '702', '703', '704']),
+            prop('effect')
+        )
+    ]),
+    always(11),
+    always(undefined)
+)
+
+const fns = {
+    item_names: always(1),
+    item,
+    quality,
+    intent: always('dual'),
+    australium,
+    killstreak_tier,
+    craftable,
+    page_size: always(30),
+    particle,
+    item_type,
+    texture_name,
+    wear_tier,
+    elevated
+}
+
+const toSearchParams = compose(
+    map(__, fns),
+    applyTo,
+    itemFromSku
+)
+
+module.exports = { toSearchParams }

package/todo.txt

@@ -0,0 +1,24 @@
+
+option 1: 
+
+call the sagas anywhere your redux-saga app + add the api context from the api.js
+
+const { fetchAppDataInventory } = require('@juice789/tf2items')
+
+function* fetchAppDataINvnetorySaga(inventory){
+    const fetched = yield call(fetchAppDataINventry, inventory)
+}
+
+function* fetchInventorySaga(){
+    yielt takeEvery('FETCH_INVENTORY', fetchAppDataInventorySaga)
+}
+
+option 2: 
+
+initialize the library as a module, functions are available as promises
+
+const { getInstance } = require('@juice789/tf2items')
+
+const app = getInstance(options)
+
+app.saveSchema().then(console.log)

package/transformItems.js

@@ -0,0 +1,106 @@
+const { prop, pick, map, compose, complement, includes, equals, length, allPass, mapObjIndexed, when, has, __, chain, assoc, pathEq, omit, split, keys, propEq, propOr, nth, of, range, path, uncurryN, mergeDeepRight, reduce, concat } = require('ramda')
+const { qualityIds, strangifierTargets, crateSeries, chemsetDefindex } = require('./schemaHelper.json')
+
+const propsToKeep = [
+    'name',
+    'defindex',
+    'item_class',
+    'item_name',
+    'propername',
+    'item_slot',
+    'used_by_classes',
+    'untradable',
+    'festivized',
+    'type2',
+    'texture',
+    'target',
+    'series',
+    'seriesHidden',
+    'item_quality'
+]
+
+const transformItems = uncurryN(3, (collections, itemsApi) => compose(
+    map((item) => mergeDeepRight(collections[item.name], item)),
+    reduce(mergeDeepRight, {}),
+    concat([itemsApi, crateSeries, strangifierTargets, chemsetDefindex]),
+    of,
+    map(
+        compose(
+            pick(propsToKeep),
+            when(
+                allPass([
+                    compose(Boolean, prop('item_slot')),
+                    compose(includes(__, ['primary', 'melee', 'secondary', 'pda', 'pda2', 'building']), prop('item_slot')),
+                    compose(
+                        includes(__, range(2, 9)),
+                        length,
+                        prop('used_by_classes')
+                    )
+                ]),
+                assoc('used_by_classes', ['multi'])
+            ),
+            when(
+                allPass([
+                    compose(Boolean, prop('item_slot')),
+                    compose(equals(9), length, prop('used_by_classes'))
+                ]),
+                assoc('used_by_classes', ['all'])
+            ),
+            when(
+                has('used_by_classes'),
+                chain(assoc('used_by_classes'), compose(keys, prop('used_by_classes')))
+            ),
+            when(
+                compose(complement(Boolean), prop('item_name')),
+                chain(assoc('item_name'), prop('name'))
+            ),
+            when(
+                path(['static_attrs', 'tool target item']),
+                chain(assoc('target'), compose(of, path(['static_attrs', 'tool target item'])))
+            ),
+            when(
+                path(['static_attrs', 'hide crate series number']),
+                assoc('seriesHidden', true)
+            ),
+            when(
+                path(['static_attrs', 'set supply crate series']),
+                chain(assoc('series'), compose(of, path(['static_attrs', 'set supply crate series'])))
+            ),
+            when(
+                path(['attributes', 'tool target item', 'value']),
+                chain(assoc('target'), compose(of, path(['attributes', 'tool target item', 'value'])))
+            ),
+            when(
+                pathEq(['tags', 'can_be_festivized'], '1'),
+                assoc('festivized', '1')
+            ),
+            when(
+                pathEq(['attributes', 'cannot trade', 'value'], '1'),
+                assoc('untradable', '1')
+            ),
+            when(
+                pathEq(['tool', 'type'], 'paint_can'),
+                assoc('type2', 'paint')
+            ),
+            when(
+                pathEq(['tool', 'type'], 'decoder_ring'),
+                assoc('type2', 'key')
+            ),
+            when(
+                has('item_quality'),
+                chain(assoc('item_quality'), compose(prop(__, qualityIds), nth(0), split(' '), prop('item_quality')))
+            ),
+            when(
+                allPass([
+                    compose(includes('paintkitweapon'), propOr('', 'item_quality')),
+                    complement(propEq)('defindex', '9536')
+                ]),
+                chain(assoc('texture'), path(['static_attrs', 'paintkit_proto_def_index']))
+            )
+        )
+    ),
+    omit(['default']),
+    mapObjIndexed((v, k) => assoc('defindex', k, v))
+))
+
+module.exports = { transformItems }