@juice789/tf2items 1.0.0

package/fromEconItem.js

@@ -0,0 +1,359 @@
+const {
+    compose,
+    includes,
+    prop,
+    propOr,
+    find,
+    flip,
+    map,
+    when,
+    unary,
+    allPass,
+    propEq,
+    uncurryN,
+    chain,
+    __,
+    ifElse,
+    has,
+    always,
+    curry,
+    applyTo,
+    assoc,
+    pathOr,
+    invertObj,
+    mergeRight,
+    values,
+    replace,
+    trim,
+    reduce,
+    nth,
+    split,
+    propSatisfies,
+    pathEq,
+    complement,
+    either,
+    concat,
+    of,
+    path,
+    equals,
+    pick
+} = require('ramda')
+
+const { safeItems: items } = require('./schemaItems.js')
+const { particleEffects, textures } = require('./schema.json')
+const { qualityNames, wears } = require('./schemaHelper.json')
+const { skuFromItem } = require('./sku.js')
+const { renameKeys } = require('ramda-adjunct')
+
+const marketHashIncludes = curry((string, { market_hash_name }) => market_hash_name.indexOf(string) !== -1)
+
+const removeStrings = curry((string, strings) => compose(
+    trim,
+    replace(/\s\s+/g, ' '),
+    reduce((all, curr) => replace(curr, '', all), string || '')
+)(strings))
+
+const findTag = uncurryN(2, (tagName) => compose(
+    prop('name'),
+    find(propEq('category_name', tagName)),
+    map(renameKeys({
+        localized_category_name: 'category_name',
+        localized_tag_name: 'name'
+    })),
+    propOr([], 'tags')
+))
+
+const old_id = ifElse(
+    has('new_assetid'),
+    prop('assetid'),
+    always(null)
+)
+
+const id = chain(
+    propOr(__, 'new_assetid'),
+    prop('assetid')
+)
+
+const recipe = compose(
+    find(__, ['Fabricator', 'Strangifier Chemistry Set', 'Chemistry Set']),
+    flip(marketHashIncludes),
+)
+
+
+const series = ifElse(
+    compose(equals('Crate'), findTag('Type')),
+    ifElse(
+        marketHashIncludes('#'),
+        compose(
+            nth(1),
+            split('#'),
+            prop('market_hash_name')
+        ),
+        compose(
+            nth(0),
+            propOr([], 'series'),
+            prop(__, items),
+            path(['app_data', 'def_index'])
+        )
+    ),
+    always(null)
+)
+
+const craft = ifElse(
+    allPass([
+        propSatisfies(includes('#'), 'name'),
+        propSatisfies(complement(includes)('#'), 'market_hash_name'),
+    ]),
+    compose(
+        nth(1),
+        split('#'),
+        prop('name')
+    ),
+    always(null)
+)
+
+const australium = allPass([
+    pathEq(['app_data', 'quality'], '11'),
+    marketHashIncludes('Australium')
+])
+
+const wear = compose(
+    prop(__, invertObj(wears)),
+    removeStrings(__, ['(', ')']),
+    findTag('Exterior')
+)
+
+const texture = ifElse(
+    findTag('Exterior'),
+    compose(
+        propOr('-1', __, invertObj(textures)),
+        ({ app_data, market_hash_name }) => removeStrings(market_hash_name, [
+            'Specialized Killstreak',
+            'Professional Killstreak',
+            'Killstreak',
+            '(Field-Tested)',
+            '(Well-Worn)',
+            '(Battle Scarred)',
+            '(Minimal Wear)',
+            '(Factory New)',
+            'Festivized',
+            'Strange',
+            qualityNames[app_data.quality],
+            items[app_data.def_index].item_name
+        ])
+    ),
+    always(null)
+)
+
+const festivized = marketHashIncludes('Festivized')
+
+const killstreakTier = compose(
+    prop(__, { 'Professional Killstreak': '3', 'Specialized Killstreak': '2', 'Killstreak': '1' }),
+    find(__, ['Professional Killstreak', 'Specialized Killstreak', 'Killstreak']),
+    flip(marketHashIncludes)
+)
+
+const effect = ifElse(
+    allPass([
+        pathEq(['app_data', 'quality'], '5'),
+        compose(
+            find(propEq('color', 'ffd700')),
+            propOr([], 'descriptions')
+        )
+    ]),
+    compose(
+        propOr('-1', __, invertObj(particleEffects)),
+        replace('★ Unusual Effect: ', ''),
+        prop('value'),
+        find(propEq('color', 'ffd700')),
+        propOr([], 'descriptions')
+    ),
+    always(null)
+)
+
+const elevated = allPass([
+    complement(pathEq)(['app_data', 'quality'], '11'),
+    compose(
+        includes('Strange'),
+        ({ app_data, market_hash_name }) => replace(items[app_data.def_index].item_name, '', market_hash_name)
+    )
+])
+
+const uncraftable = compose(
+    Boolean,
+    find(propEq('value', '( Not Usable in Crafting )')),
+    propOr([], 'descriptions')
+)
+
+const market_hash_name = prop('market_hash_name')
+
+const quality = pathOr('-1', ['app_data', 'quality'])
+
+const defindex = pathOr('-1', ['app_data', 'def_index'])
+
+const propsTf2_1 = {
+    defindex,
+    quality,
+    market_hash_name,
+    uncraftable,
+    elevated,
+    effect,
+    killstreakTier,
+    festivized,
+    texture,
+    wear,
+    australium,
+    series,
+    craft,
+    recipe,
+    id,
+    old_id
+}
+
+const isTarget = either(
+    compose(
+        find(__, ['Strangifier', 'Fabricator', 'Strangifier Chemistry Set', 'Unusualifier']),
+        flip(marketHashIncludes),
+    ),
+    allPass([
+        marketHashIncludes('Kit'),
+        marketHashIncludes('Killstreak')
+    ])
+)
+
+const target = ifElse(
+    isTarget,
+    compose(
+        propOr('-1', 'defindex'),
+        find(__, values(items)),
+        allPass,
+        concat([propSatisfies(complement(includes)(__, [0, 15]), 'item_quality')]),
+        of,
+        propEq('item_name'),
+        ({ market_hash_name, defindex }) => removeStrings(market_hash_name, [
+            'Strangifier',
+            'Unusual',
+            'Unusualifier',
+            items[defindex].item_name,
+            'Specialized Killstreak',
+            'Professional Killstreak',
+            'Killstreak',
+            "Collector's",
+            'Series',
+            'Kit',
+            'Fabricator',
+            'Chemistry Set',
+            '#1',
+            '#2',
+            '#3'
+        ])
+    ),
+    always(null)
+)
+
+const output = ({ recipe, market_hash_name, killstreakTier }) => {
+    switch (recipe) {
+        case 'Fabricator':
+            const ktMap = {
+                '2': '6523',
+                '3': '6526'
+            }
+            return ktMap[killstreakTier]
+        case 'Strangifier Chemistry Set':
+            return '6522'
+        case 'Chemistry Set':
+            return compose(
+                propOr('-1', 'defindex'),
+                find(__, values(items)),
+                allPass,
+                concat([propSatisfies(complement(includes)(__, [0, 15]), 'item_quality')]),
+                of,
+                propEq('item_name'),
+                removeStrings(__, ['Chemistry Set', "Collector's"])
+            )(market_hash_name)
+        default:
+            return null
+    }
+}
+
+const oq = ({ market_hash_name, recipe }) => recipe
+    ? includes("Collector's", market_hash_name) ? '14' : '6'
+    : null
+
+const propsTf2_2 = {
+    target,
+    output,
+    oq
+}
+
+const propsOtherGame = {
+    sku: market_hash_name,
+    id,
+    old_id
+}
+
+const keyRemap = when(
+    compose(
+        includes(__, ['5021', '5049', '5067', '5072', '5073', '5079', '5081', '5628', '5631', '5632', '5713', '5716', '5717', '5762', '5791', '5792']), //old keys that turned into regular keys
+        String,
+        prop('defindex')
+    ),
+    compose(
+        assoc('defindex', '5021'),
+        assoc('uncraftable', false)
+    )
+)
+
+const kitRemap = when(
+    compose(
+        includes('Killstreakifier Basic'),
+        propOr('', 'name'),
+        prop(__, items),
+        prop('defindex')
+    ),
+    assoc('defindex', '6527')
+)
+
+const otherIndex = {
+    5844: '5710', //fall acorns key
+    5845: '5720', //strongbox key
+    5846: '5740', //stockpile key
+    5847: '5827', //gargoyle key
+    5738: '5737', //stockpile crate
+}
+
+const otherRemap = when(
+    compose(has(__, otherIndex), prop('defindex')),
+    chain(assoc('defindex'), compose(prop(__, otherIndex), prop('defindex')))
+)
+
+const remaps = compose(
+    kitRemap,
+    keyRemap,
+    otherRemap
+)
+
+const fromEconItem440 = compose(
+    pick(['sku', 'id', 'old_id']),
+    chain(assoc('sku'), skuFromItem),
+    remaps,
+    chain(mergeRight, compose(map(__, propsTf2_2), applyTo)),
+    map(__, propsTf2_1),
+    unary(applyTo)
+)
+
+const fromEconItemOther = compose(
+    map(__, propsOtherGame),
+    unary(applyTo)
+)
+
+const fromEconItem = ifElse(
+    propEq('appid', 440),
+    fromEconItem440,
+    fromEconItemOther
+)
+
+module.exports = {
+    fromEconItem,
+    kitRemap
+}

package/fromListingV1.js

@@ -0,0 +1,374 @@
+const {
+    compose,
+    complement,
+    propEq,
+    hasPath,
+    F,
+    prop,
+    chain,
+    assoc,
+    map,
+    __,
+    applyTo,
+    cond,
+    identity,
+    T,
+    flatten,
+    toPairs,
+    pathOr,
+    pickBy,
+    indexBy,
+    propOr,
+    path,
+    find,
+    includes,
+    values,
+    nth,
+    has,
+    when,
+    allPass,
+    converge,
+    or,
+    take,
+    uncurryN
+} = require('ramda')
+
+const { safeItems: items } = require('./schemaItems.js')
+const { textures } = require('./schema.json')
+const { skuFromItem } = require('./sku.js')
+
+const {
+    kitRemap
+} = require('./fromEconItem.js')
+
+const findValue = uncurryN(2, (fns) => compose(
+    find(Boolean),
+    map(__, fns),
+    applyTo
+))
+
+const isWeaponEffect = compose(includes(__, ['701', '702', '703', '704']), String)
+
+const defindex = prop('defindex')
+
+const quality = prop('quality')
+
+const uncraftable = compose(Boolean, prop('flag_cannot_craft'))
+
+const effectOptions = [
+    path(['attributes', '134', 'float_value']),
+    path(['attributes', '2041', 'value']),
+]
+
+const effect = findValue(effectOptions)
+
+const elevated = cond(
+    [
+        [complement(propEq)('quality', 11), hasPath(['attributes', '214'])],
+        [propEq('quality', 11), compose(isWeaponEffect, effect)],
+        [T, F]
+    ]
+)
+
+const ktRemap = {
+    '6527': '1',
+    '6523': '2',
+    '6526': '3',
+    '20002': '2',
+    '20003': '3'
+}
+
+const ktOptions = [
+    path(['attributes', '2025', 'float_value']),
+    compose(prop(__, ktRemap), prop('defindex'))
+]
+
+const killstreakTier = findValue(ktOptions)
+
+const festivized = hasPath(['attributes', '2053'])
+
+const texture = path(['attributes', '834', 'value'])
+
+const wears = {
+    '0': null,
+    '0.2': '1',
+    '0.4': '2',
+    '0.6': '3',
+    '0.8': '4',
+    '1': '5'
+}
+
+const wear = compose(
+    prop(__, wears),
+    take(3),
+    String,
+    pathOr('0', ['attributes', '725', 'float_value'])
+)
+
+const australium = hasPath(['attributes', '2027'])
+
+const series = path(['attributes', '187', 'float_value'])
+
+const findOutput = compose(
+    find(compose(includes(__, [true, 'true']), prop('is_output'))),
+    values,
+    propOr({}, 'attributes')
+)
+
+const findRecipeTarget = compose(
+    prop('float_value'),
+    find(compose(includes(__, ['2012', 2012]), prop('defindex'))),
+    propOr([], 'attributes'),
+    findOutput
+)
+
+const targetOptions = [
+    path(['attributes', '2012', 'float_value']),
+    findRecipeTarget
+]
+
+const target = findValue(targetOptions)
+
+const output = compose(
+    prop('itemdef'),
+    findOutput
+)
+
+const oq = compose(
+    prop('quality'),
+    findOutput
+)
+
+const fns = {
+    defindex,
+    quality,
+    uncraftable,
+    elevated,
+    effect,
+    killstreakTier,
+    festivized,
+    texture,
+    wear,
+    australium,
+    series,
+    target,
+    output,
+    oq
+}
+
+const remap = (fn1, fn2) => when(
+    fn1,
+    chain(
+        assoc('defindex'),
+        converge(
+            or,
+            [
+                fn2,
+                prop('defindex')
+            ]
+        )
+    )
+)
+
+const remapStrangifier = remap(
+    compose(
+        propEq('item_name', 'Strangifier'),
+        prop(__, items),
+        prop('defindex')
+    ),
+    compose(
+        prop('defindex'),
+        nth(0),
+        values,
+        (listingTarget) => pickBy(
+            compose(
+                includes(listingTarget.toString()),
+                propOr([], 'target')
+            ),
+            items
+        ),
+        prop('target')
+    )
+)
+
+const strangifierSets = pickBy(allPass([
+    has('td'),
+    propEq('item_name', 'Chemistry Set')
+]), items)
+
+const remapStrangifierSet = remap(
+    allPass([
+        propEq('defindex', 20001),
+        prop('output'),
+        prop('target')
+    ]),
+    compose(
+        prop('defindex'),
+        nth(0),
+        values,
+        (listingTarget) => pickBy(
+            compose(
+                includes(listingTarget.toString()),
+                prop('td')
+            ),
+            strangifierSets
+        ),
+        prop('target'),
+    )
+)
+
+const collectorSets = pickBy(allPass([
+    complement(prop)('td'),
+    prop('od'),
+    propEq('item_name', 'Chemistry Set'),
+]), items)
+
+const remapCollectorSet = remap(
+    allPass([
+        propEq('defindex', 20001),
+        complement(prop)('target')
+    ]),
+    compose(
+        prop('defindex'),
+        nth(0),
+        values,
+        (listingOutput) => pickBy(
+            compose(
+                includes(listingOutput.toString()),
+                prop('od')
+            ),
+            collectorSets
+        ),
+        prop('output')
+    )
+)
+
+
+const weaponIndex = {
+    "0": 190,
+    "1": 191,
+    "13": 200,
+    "14": 201,
+    "15": 202,
+    "16": 203,
+    "17": 204,
+    "18": 205,
+    "19": 206,
+    "2": 192,
+    "20": 207,
+    "21": 208,
+    "22": 209,
+    "23": 209,
+    "24": 210,
+    "25": 737,
+    "29": 211,
+    "3": 193,
+    "30": 212,
+    "4": 194,
+    "5": 195,
+    "6": 196,
+    "7": 197,
+    "735": 736,
+    "8": 198,
+    "9": 199,
+    "10": 199,
+    "11": 199,
+    "12": 199
+}
+
+const remapWeapon = when(
+    compose(has(__, weaponIndex), prop('defindex')),
+    chain(assoc('defindex'), compose(prop(__, weaponIndex), prop('defindex')))
+)
+
+const decodeSkinQuality = cond([
+    [allPass([propEq('quality', 15), compose(isWeaponEffect, prop('effect'))]), assoc('quality', 5)], //decorated + effect = unusual
+    [allPass([propEq('quality', 11), compose(isWeaponEffect, prop('effect'))]), assoc('quality', 5)], //strange + effect = unusual
+    [allPass([propEq('quality', 15), complement(prop)('effect'), prop('elevated')]), assoc('quality', 11)], //decorated + elevated = strange
+    [T, identity]
+])
+
+const unboxedSkins = map(
+    (item) => assoc('item_name', textures[item.texture] + ' ' + item.item_name, item),
+    pickBy(propEq('item_quality', 15), items)
+)
+
+const unboxSkinsRemap = remap(
+    prop('texture'),
+    compose(
+        nth(0),
+        flatten,
+        toPairs,
+        ({ defindex, texture }) => pickBy(
+            propEq('item_name', textures[texture] + ' ' + items[defindex].item_name),
+            unboxedSkins
+        )
+    )
+)
+
+const remapCrateSeries = remap(
+    prop('series'),
+    compose(
+        prop('defindex'),
+        find(
+            __,
+            values(items)
+        ),
+        (s) => compose(
+            includes(s),
+            propOr([], 'series')
+        ),
+        String,
+        prop('series')
+    )
+)
+
+const promoIndex = {
+    "30720": "30740",
+    "30721": "30741",
+    "30724": "30739",
+    "810": "831",
+    "811": "832",
+    "812": "833",
+    "813": "834",
+    "814": "835",
+    "815": "836",
+    "816": "837",
+    "817": "838"
+}
+
+const promoRemap = when(
+    allPass([
+        compose(has(__, promoIndex), prop('defindex')),
+        propEq('quality', 1)
+    ]),
+    chain(assoc('defindex'), compose(prop(__, promoIndex), prop('defindex')))
+)
+
+const remaps = compose(
+    remapCrateSeries,
+    unboxSkinsRemap,
+    kitRemap,
+    promoRemap,
+    decodeSkinQuality,
+    remapWeapon,
+    remapCollectorSet,
+    remapStrangifierSet,
+    remapStrangifier
+)
+
+const fromListingV1 = compose(
+    skuFromItem,
+    remaps,
+    map(__, fns),
+    applyTo,
+    chain(
+        assoc('attributes'),
+        compose(
+            indexBy(prop('defindex')),
+            propOr([], 'attributes')
+        )
+    )
+)
+
+module.exports = { fromListingV1, remaps }