@juice789/tf2items 1.0.39 → 2.0.1

package/fromListingV1.js

@@ -1,74 +1,31 @@
-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'))
+import { safeItems as items } from './schemaItems.js'
+import schema from './schema.json' with { type: 'json' }
+const { textures } = schema
+import { skuFromItem } from './sku.js'
+import { kitRemap } from './fromEconItem.js'
+
+function coalesce(fns, item) {
+    return fns.map(fn => fn(item)).find(Boolean)
+}
+
+const isWeaponEffect = x => ['701', '702', '703', '704'].includes(String(x))
+
+const defindex = item => item.defindex
+
+const quality = item => item.quality
+
+const uncraftable = item => Boolean(item.flag_cannot_craft)
 
 const effectOptions = [
-    path(['attributes', '134', 'float_value']),
-    path(['attributes', '2041', 'value']),
+    item => item?.attributes?.['134']?.float_value,
+    item => item?.attributes?.['2041']?.value,
 ]
 
-const effect = findValue(effectOptions)
+const effect = item => coalesce(effectOptions, item)
 
-const elevated = cond(
-    [
-        [complement(propEq)(11, 'quality'), hasPath(['attributes', '214'])],
-        [propEq(11, 'quality'), compose(isWeaponEffect, effect)],
-        [T, F]
-    ]
-)
+const elevated = item => item.quality === 11
+    ? isWeaponEffect(effect(item))
+    : '214' in (item.attributes ?? {})
 
 const ktRemap = {
     '6527': '1',
@@ -79,15 +36,15 @@ const ktRemap = {
 }
 
 const ktOptions = [
-    path(['attributes', '2025', 'float_value']),
-    compose(prop(__, ktRemap), prop('defindex'))
+    item => item?.attributes?.['2025']?.float_value,
+    item => ktRemap[item.defindex]
 ]
 
-const killstreakTier = findValue(ktOptions)
+const killstreakTier = item => coalesce(ktOptions, item)
 
-const festivized = hasPath(['attributes', '2053'])
+const festivized = item => '2053' in (item.attributes ?? {})
 
-const texture = path(['attributes', '834', 'value'])
+const texture = item => item?.attributes?.['834']?.value
 
 const wears = {
     '0': null,
@@ -98,46 +55,31 @@ const wears = {
     '1': '5'
 }
 
-const wear = compose(
-    prop(__, wears),
-    take(3),
-    String,
-    pathOr('0', ['attributes', '725', 'float_value'])
-)
+const wear = item => wears[String(item?.attributes?.['725']?.float_value ?? '0').slice(0, 3)]
 
-const australium = hasPath(['attributes', '2027'])
+const australium = item => '2027' in (item.attributes ?? {})
 
-const series = path(['attributes', '187', 'float_value'])
+const series = item => item?.attributes?.['187']?.float_value
 
-const findOutput = compose(
-    find(compose(includes(__, [true, 'true']), prop('is_output'))),
-    values,
-    propOr({}, 'attributes')
-)
+const findOutput = item => Object.values(item.attributes ?? {})
+    .find(attr => [true, 'true'].includes(attr.is_output))
 
-const findRecipeTarget = compose(
-    prop('float_value'),
-    find(compose(includes(__, ['2012', 2012]), prop('defindex'))),
-    propOr([], 'attributes'),
-    findOutput
-)
+const findRecipeTarget = item => {
+    const out = findOutput(item)
+    const attr = (out?.attributes ?? []).find(a => ['2012', 2012].includes(a.defindex))
+    return attr?.float_value
+}
 
 const targetOptions = [
-    path(['attributes', '2012', 'float_value']),
+    item => item?.attributes?.['2012']?.float_value,
     findRecipeTarget
 ]
 
-const target = findValue(targetOptions)
+const target = item => coalesce(targetOptions, item)
 
-const output = compose(
-    prop('itemdef'),
-    findOutput
-)
+const output = item => findOutput(item)?.itemdef
 
-const oq = compose(
-    prop('quality'),
-    findOutput
-)
+const oq = item => findOutput(item)?.quality
 
 const fns = {
     defindex,
@@ -156,94 +98,42 @@ const fns = {
     oq
 }
 
-const remap = (fn1, fn2) => when(
-    fn1,
-    chain(
-        assoc('defindex'),
-        converge(
-            or,
-            [
-                fn2,
-                prop('defindex')
-            ]
-        )
-    )
-)
+const remap = (fn1, fn2) => item => fn1(item)
+    ? { ...item, defindex: fn2(item) || item.defindex }
+    : item
 
 const remapStrangifier = remap(
-    compose(
-        propEq('Strangifier', 'item_name'),
-        prop(__, items),
-        prop('defindex')
-    ),
-    compose(
-        prop('defindex'),
-        nth(0),
-        values,
-        (listingTarget) => pickBy(
-            compose(
-                includes(listingTarget.toString()),
-                propOr([], 'target')
-            ),
-            items
-        ),
-        prop('target')
-    )
+    item => items[item.defindex]?.item_name === 'Strangifier',
+    item => {
+        const t = String(item.target)
+        return Object.values(items).find(v => (v.target ?? []).includes(t))?.defindex
+    }
 )
 
-const strangifierSets = pickBy(allPass([
-    has('td'),
-    propEq('Chemistry Set', 'item_name')
-]), items)
+const strangifierSets = Object.fromEntries(
+    Object.entries(items).filter(([, v]) => 'td' in v && v.item_name === 'Chemistry Set')
+)
 
 const remapStrangifierSet = remap(
-    allPass([
-        propEq(20001, 'defindex'),
-        prop('output'),
-        prop('target')
-    ]),
-    compose(
-        prop('defindex'),
-        nth(0),
-        values,
-        (listingTarget) => pickBy(
-            compose(
-                includes(listingTarget.toString()),
-                prop('td')
-            ),
-            strangifierSets
-        ),
-        prop('target'),
-    )
+    item => item.defindex === 20001 && item.output && item.target,
+    item => {
+        const t = String(item.target)
+        return Object.values(strangifierSets).find(v => v.td?.includes(t))?.defindex
+    }
 )
 
-const collectorSets = pickBy(allPass([
-    complement(prop)('td'),
-    prop('od'),
-    propEq('Chemistry Set', 'item_name'),
-]), items)
+const collectorSets = Object.fromEntries(
+    Object.entries(items).filter(([, v]) => !v.td && v.od && v.item_name === 'Chemistry Set')
+)
 
 const remapCollectorSet = remap(
-    allPass([
-        propEq(20001, 'defindex'),
-        complement(prop)('target')
-    ]),
-    compose(
-        prop('defindex'),
-        nth(0),
-        values,
-        (listingOutput) => pickBy(
-            compose(
-                includes(listingOutput.toString()),
-                prop('od')
-            ),
-            collectorSets
-        ),
-        prop('output')
-    )
+    item => item.defindex === 20001 && !item.target,
+    item => {
+        const o = String(item.output)
+        return Object.values(collectorSets).find(v => v.od?.includes(o))?.defindex
+    }
 )
 
-
 const weaponIndex = {
     "0": 190,
     "1": 191,
@@ -276,51 +166,37 @@ const weaponIndex = {
     "12": 199
 }
 
-const remapWeapon = when(
-    compose(has(__, weaponIndex), prop('defindex')),
-    chain(assoc('defindex'), compose(prop(__, weaponIndex), prop('defindex')))
-)
+const remapWeapon = item => item.defindex in weaponIndex
+    ? { ...item, defindex: weaponIndex[item.defindex] }
+    : item
 
-const decodeSkinQuality = cond([
-    [allPass([propEq(15, 'quality'), compose(isWeaponEffect, prop('effect'))]), assoc('quality', 5)], //decorated + effect = unusual
-    [allPass([propEq(11, 'quality'), compose(isWeaponEffect, prop('effect'))]), assoc('quality', 5)], //strange + effect = unusual
-    [allPass([propEq(15, 'quality'), complement(prop)('effect'), prop('elevated')]), assoc('quality', 11)], //decorated + elevated = strange
-    [T, identity]
-])
+function decodeSkinQuality(item) {
+    if (item.quality === 15 && isWeaponEffect(item.effect)) return { ...item, quality: 5 } // decorated + effect = unusual
+    if (item.quality === 11 && isWeaponEffect(item.effect)) return { ...item, quality: 5 } // strange + effect = unusual
+    if (item.quality === 15 && !item.effect && item.elevated) return { ...item, quality: 11 } // decorated + elevated = strange
+    return item
+}
 
-const unboxedSkins = map(
-    (item) => assoc('item_name', textures[item.texture] + ' ' + item.item_name, item),
-    pickBy(propEq(15, 'item_quality'), items)
+const unboxedSkins = Object.fromEntries(
+    Object.entries(items)
+        .filter(([, v]) => v.item_quality === 15)
+        .map(([k, v]) => [k, { ...v, item_name: textures[v.texture] + ' ' + v.item_name }])
 )
 
 const unboxSkinsRemap = remap(
-    prop('texture'),
-    compose(
-        nth(0),
-        flatten,
-        toPairs,
-        ({ defindex, texture }) => pickBy(
-            propEq(textures[texture] + ' ' + items[defindex].item_name, 'item_name'),
-            unboxedSkins
-        )
-    )
+    item => item.texture,
+    item => {
+        const expectedName = textures[item.texture] + ' ' + items[item.defindex].item_name
+        return Object.entries(unboxedSkins).find(([, v]) => v.item_name === expectedName)?.[0]
+    }
 )
 
 const remapCrateSeries = remap(
-    prop('series'),
-    compose(
-        prop('defindex'),
-        find(
-            __,
-            values(items)
-        ),
-        (s) => compose(
-            includes(s),
-            propOr([], 'series')
-        ),
-        String,
-        prop('series')
-    )
+    item => item.series,
+    item => {
+        const s = String(item.series)
+        return Object.values(items).find(v => (v.series ?? []).includes(s))?.defindex
+    }
 )
 
 const promoIndex = {
@@ -337,38 +213,27 @@ const promoIndex = {
     "817": "838"
 }
 
-const promoRemap = when(
-    allPass([
-        compose(has(__, promoIndex), prop('defindex')),
-        propEq(1, 'quality')
-    ]),
-    chain(assoc('defindex'), compose(prop(__, promoIndex), prop('defindex')))
-)
+const promoRemap = item => item.defindex in promoIndex && item.quality === 1
+    ? { ...item, defindex: promoIndex[item.defindex] }
+    : item
 
-const remaps = compose(
-    remapCrateSeries,
-    unboxSkinsRemap,
-    kitRemap,
-    promoRemap,
-    decodeSkinQuality,
-    remapWeapon,
-    remapCollectorSet,
+export const remaps = item => [
+    remapStrangifier,
     remapStrangifierSet,
-    remapStrangifier
-)
+    remapCollectorSet,
+    remapWeapon,
+    decodeSkinQuality,
+    promoRemap,
+    kitRemap,
+    unboxSkinsRemap,
+    remapCrateSeries,
+].reduce((acc, fn) => fn(acc), item)
 
-const fromListingV1 = compose(
-    skuFromItem,
-    remaps,
-    map(__, fns),
-    applyTo,
-    chain(
-        assoc('attributes'),
-        compose(
-            indexBy(prop('defindex')),
-            propOr([], 'attributes')
-        )
+export function fromListingV1(item) {
+    const indexedAttrs = Object.fromEntries(
+        (item.attributes ?? []).map(a => [a.defindex, a])
     )
-)
-
-module.exports = { fromListingV1, remaps }
+    const normalized = { ...item, attributes: indexedAttrs }
+    const mapped = Object.fromEntries(Object.entries(fns).map(([k, fn]) => [k, fn(normalized)]))
+    return skuFromItem(remaps(mapped))
+}

package/fromListingV2.js

@@ -1,69 +1,41 @@
-const {
-    compose,
-    propEq,
-    prop,
-    map,
-    __,
-    applyTo,
-    pathOr,
-    includes,
-    pathEq,
-    propOr,
-    ifElse,
-    equals,
-    length,
-    split,
-    allPass,
-    nth,
-    cond,
-    T,
-    F,
-    complement
-} = require('ramda')
+import { skuFromItem } from './sku.js'
+import { remaps } from './fromListingV1.js'
 
-const { skuFromItem } = require('./sku.js')
-const { remaps } = require('./fromListingV1.js')
+const defindex = item => item.defindex
 
-const defindex = prop('defindex')
+const quality = item => item?.quality?.id ?? null
 
-const quality = pathOr(null, ['quality', 'id'])
+const uncraftable = item => item.name?.includes('Non-Craftable') ?? false
 
-const uncraftable = compose(includes('Non-Craftable'), prop('name'))
+const effect = item => item?.particle?.id ?? null
 
-const effect = pathOr(null, ['particle', 'id'])
+const elevated = item => (item?.quality?.id ?? null) === 11
+    ? ['701', '702', '703', '704'].includes(String(item?.particle?.id ?? null))
+    : (item?.elevatedQuality?.id ?? null) === 11
 
-const elevated = cond(
-    [
-        [compose(complement(equals)(11), quality), compose(equals(11), pathOr(null, ['elevatedQuality', 'id']))],
-        [compose(equals(11), quality), compose(includes(__, ['701', '702', '703', '704']), String, effect)],
-        [T, F]
-    ]
-)
+const killstreakTier = item => item.killstreakTier ?? null
 
-const killstreakTier = propOr(null, 'killstreakTier')
+const festivized = item => item.festivized === true
 
-const festivized = propEq(true, 'festivized')
+const texture = item => item?.texture?.id ?? null
 
-const texture = pathOr(null, ['texture', 'id'])
+const wear = item => item?.wearTier?.id ?? null
 
-const wear = pathOr(null, ['wearTier', 'id'])
+const australium = item => item.australium === true
 
-const australium = propEq(true, 'australium')
+const series = item => item.crateSeries ?? null
 
-const series = propOr(null, 'crateSeries')
-
-const target = ifElse(
-    allPass([
-        pathEq(null, ['recipe', 'targetItem']),
-        compose(equals(3), length, split('-'), prop('priceindex'))
-    ]),
-    compose(nth(2), split('-'), prop('priceindex')),
-    pathOr(null, ['recipe', 'targetItem', '_source', 'defindex'])
-)
+const target = item => {
+    const parts = (item.priceindex ?? '').split('-')
+    if (item?.recipe?.targetItem === null && parts.length === 3) {
+        return parts[2]
+    }
+    return item?.recipe?.targetItem?._source?.defindex ?? null
+}
 
-const output = pathOr(null, ['recipe', 'outputItem', 'defindex'])
+const output = item => item?.recipe?.outputItem?.defindex ?? null
 
-const oq = pathOr(null, ['recipe', 'outputItem', 'quality', 'id'])
+const oq = item => item?.recipe?.outputItem?.quality?.id ?? null
 
 const fns = {
     defindex,
@@ -82,11 +54,7 @@ const fns = {
     oq
 }
 
-const fromListingV2 = compose(
-    skuFromItem,
-    remaps,
-    map(__, fns),
-    applyTo
-)
-
-module.exports = { fromListingV2 }
+export function fromListingV2(item) {
+    const mapped = Object.fromEntries(Object.entries(fns).map(([k, fn]) => [k, fn(item)]))
+    return skuFromItem(remaps(mapped))
+}

package/getCollections.js

@@ -1,33 +1,17 @@
-const { prop, map, compose, toLower, mapObjIndexed, toPairs, when, has, __, chain, assoc, reduce, mergeRight, values, path, uncurryN, replace, mapKeys } = require('ramda')
+export function getCollections(english, itemsGame) {
+    const collections = {}
+    for (const collection of Object.values(itemsGame.item_collections)) {
+        collections[collection.name.replace('#', '')] = collection
+    }
 
-const simplifyCollections = compose(
-    reduce((curr, obj) => mergeRight(curr, obj), {}),
-    values,
-    mapObjIndexed(
-        (collection, key) => map(assoc('collection', key), collection)
-    ),
-    map(
-        compose(
-            reduce((curr, obj) => mergeRight(curr, obj), {}),
-            map(([rarity, items]) => map(() => ({ rarity }), items)),
-            toPairs,
-            prop('items')
-        )
-    ),
-    (collections) => mapKeys((key) => replace('#', '', path([key, 'name'], collections)), collections),
-    prop('item_collections')
-)
-
-const localizeCollections = uncurryN(2, (english) => map(
-    when(
-        compose(has(__, english), compose(toLower, prop('collection'))),
-        chain(assoc('collection'), compose(prop(__, english), toLower, prop('collection')))
-    )
-))
-
-const getCollections = uncurryN(2, (english) => compose(
-    localizeCollections(english),
-    simplifyCollections
-))
-
-module.exports = { getCollections }
+    const result = {}
+    for (const [collectionName, collection] of Object.entries(collections)) {
+        const localizedName = english[collectionName.toLowerCase()] ?? collectionName
+        for (const [rarity, items] of Object.entries(collection.items)) {
+            for (const key of Object.keys(items)) {
+                result[key] = { rarity, collection: localizedName }
+            }
+        }
+    }
+    return result
+}

package/getItems.js

@@ -1,42 +1,35 @@
-const { prop, map, compose, toLower, when, has, __, chain, assoc, reduce, omit, props, split, propOr, replace, mergeDeepLeft, mergeDeepWith } = require('ramda')
+import { mergeDeepWith, mergeDeepRight } from './utils.js'
 
-function getItems(english, items_game) {
+export function getItems(english, items_game) {
 
-    var mergePrefab = (item) => mergeDeepLeft(
-        omit(['prefab'], item),
-        reduce(
-            mergeDeepWith((p, n) => p + ' ' + n),
-            {},
-            props(split(' ', item.prefab), items_game.prefabs)
+    function mergePrefab(item) {
+        const prefabKeys = item.prefab.split(' ')
+        const prefabs = prefabKeys.map(k => items_game.prefabs[k]).filter(Boolean)
+        const mergedPrefabs = prefabs.reduce(
+            (acc, prefab) => mergeDeepWith((p, n) => p + ' ' + n, acc, prefab),
+            {}
         )
-    )
-
-    var mergePrefabs = when(
-        has('prefab'),
-        (a) => mergePrefabs(mergePrefab(a))
-    )
-
-    var localize = (key) => chain(
-        assoc(key),
-        compose(
-            prop(__, english),
-            replace('#', ''),
-            toLower,
-            propOr('NaN', key)
-        )
-    )
-
-    const items = map(
-        compose(
-            localize('item_type_name'),
-            localize('item_name'),
-            mergePrefabs
-        ),
-        items_game.items
-    )
-
-    return items
+        const { prefab: _, ...rest } = item
+        return mergeDeepRight(mergedPrefabs, rest)
+    }
+
+    function mergePrefabs(item) {
+        if (!('prefab' in item)) return item
+        return mergePrefabs(mergePrefab(item))
+    }
+
+    function localize(item, key) {
+        const raw = (item[key] ?? 'NaN').toLowerCase().replace('#', '')
+        return { ...item, [key]: english[raw] }
+    }
+
+    const result = {}
+    for (const [defindex, item] of Object.entries(items_game.items)) {
+        let processed = mergePrefabs(item)
+        processed = localize(processed, 'item_name')
+        processed = localize(processed, 'item_type_name')
+        result[defindex] = processed
+    }
+    return result
 
 }
-
-module.exports = { getItems }