@juice789/tf2items 1.0.38 → 2.0.0

package/api.js

@@ -1,11 +1,10 @@
-const axios = require('axios').default
-const { compose, __, map, applyTo, prop } = require('ramda')
+import axios from 'axios'
 
 const myAxios = axios.create()
 
-myAxios.interceptors.response.use(prop('data'), Promise.reject.bind(Promise))
+myAxios.interceptors.response.use(res => res.data, Promise.reject.bind(Promise))
 
-const api = {}
+export const api = {}
 
 api.getSchemaItems = ({ steamApiKey: key }) => (start) => myAxios({
     method: 'get',
@@ -54,9 +53,4 @@ api.getAssetClassInfo = ({ steamApiKey }) => (ids, appId = 440) => myAxios({
     url: `https://api.steampowered.com/ISteamEconomy/GetAssetClassInfo/v1/?key=${steamApiKey}&appid=${appId}&language=EN&class_count=${ids.length}${ids.join('')}`
 })
 
-const createApi = compose(map(__, api), applyTo)
-
-module.exports = {
-    createApi,
-    api
-}
+export const createApi = (options) => Object.fromEntries(Object.entries(api).map(([k, fn]) => [k, fn(options)]))

package/app.js

@@ -1,57 +1,43 @@
-const { runSaga } = require('redux-saga')
-const { map } = require('ramda')
+import { runSaga } from 'redux-saga'
+import helperObjects from './schemaHelper.json' with { type: 'json' }
+import { createApi } from './api.js'
+import * as sagas from './sagas.js'
+import { saveSchema } from './saveSchema.js'
 
-const helperObjects = require('./schemaHelper.json')
-const sagaHelpers = require('./sagaHelpers')
+export * from './schemaItems.js'
+export * from './sku.js'
+export * from './skuBp.js'
+export * from './sagas.js'
+export * from './sagaHelpers.js'
+export * from './skuLinks.js'
+export { saveSchema } from './saveSchema.js'
+export { fromEconItem, fromEconItemOptions } from './fromEconItem.js'
+export { fromListingV1 } from './fromListingV1.js'
+export { fromListingV2 } from './fromListingV2.js'
+export { blanketify } from './blanket.js'
+export { createApi, api } from './api.js'
 
-const items = require('./schemaItems.js')
-const sku = require('./sku.js')
-const skuBp = require('./skuBp.js')
-const skuLinks = require('./skuLinks.js')
+export const {
+    qualityNames, qualityIds, rarities, killstreakTiers, wears, classes, itemSlots, itemClasses,
+    paintHex, paintDefindex, spellDefindex, cosmeticCollections, weaponCollections, warPaintCollections,
+    fabricatorDefindex, strangifierTargets, australiumDefindex, crateSeries, paintableDefindex,
+    chemsetDefindex, serieslessDefindex, impossibleEffects
+} = helperObjects
 
-const { createApi, api } = require('./api.js')
-
-const sagas = require('./sagas.js')
-const { saveSchema } = require('./saveSchema.js')
-
-const { fromEconItem, fromEconItemOptions } = require('./fromEconItem.js')
-const { fromListingV1 } = require('./fromListingV1.js')
-const { fromListingV2 } = require('./fromListingV2.js')
-const { blanketify } = require('./blanket.js')
-const { toSearchParams } = require('./toSearchParams.js')
-
-const getInstance = (options) => {
+export const getInstance = (options) => {
     const api = createApi(options)
     const fns = { ...sagas, saveSchema }
     return options.saga
         ? fns
-        : map(
-            (saga) => (...args) => new Promise((resolve, reject) => {
-                runSaga({
-                    context: { api }
-                }, saga, ...args)
-                    .toPromise()
-                    .then(resolve, reject)
-            }), fns
+        : Object.fromEntries(
+            Object
+                .entries(fns)
+                .map(([k, saga]) => [k, (...args) => new Promise((resolve, reject) => {
+                    runSaga({
+                        context: { api }
+                    }, saga, ...args)
+                        .toPromise()
+                        .then(resolve, reject)
+                })])
         )
 }
-
-module.exports = {
-    ...helperObjects,
-    ...items,
-    ...sku,
-    ...skuBp,
-    ...sagas,
-    ...sagaHelpers,
-    ...skuLinks,
-    saveSchema,
-    getInstance,
-    createApi,
-    api,
-    fromEconItem,
-    fromEconItemOptions,
-    fromListingV1,
-    fromListingV2,
-    blanketify,
-    toSearchParams
-}

package/blanket.js

@@ -1,122 +1,47 @@
-const {
-    defaultTo,
-    nth,
-    compose,
-    length,
-    prop,
-    map,
-    uncurryN,
-    values,
-    when,
-    includes,
-    __,
-    propEq,
-    identity,
-    filter,
-    assoc,
-    chain,
-    omit,
-    pickBy,
-    has,
-    complement,
-    allPass,
-    converge,
-    concat,
-    unnest,
-    pick,
-    mergeRight,
-    renameKeys
-} = require('ramda')
-
-const { safeItems: items } = require('./schemaItems.js')
-const { skuFromItem, itemFromSku } = require('./sku.js')
+import { safeItems as items } from './schemaItems.js'
+import { skuFromItem, itemFromSku } from './sku.js'
 
 const choose = (n, xs) =>
     n < 1 || n > xs.length
         ? []
-        : n == 1
-            ? [...xs.map(x => [x])]
+        : n === 1
+            ? xs.map(x => [x])
             : [
                 ...choose(n - 1, xs.slice(1)).map(ys => [xs[0], ...ys]),
                 ...choose(n, xs.slice(1))
             ]
 
-const getCombos = uncurryN(3, (min, max, xs) =>
-    xs.length == 0 || min > max
-        ? []
-        : [...choose(min, xs), ...getCombos(min + 1, max, xs)]
-)
+function getCombos(min, max, xs) {
+    if (xs.length === 0 || min > max) return []
+    return [...choose(min, xs), ...getCombos(min + 1, max, xs)]
+}
 
-const unboxSkinsRemap = when(
-    allPass([
-        complement(has)('texture'),//no texture
-        compose(//is an unbox skin
-            allPass([
-                has('texture'),
-                complement(propEq)('War Paint', 'item_name')
-            ]),
-            prop(__, items),
-            prop('defindex')
-        )
-    ]),
-    converge(
-        concat,
-        [
-            Array.of,
-            compose(
-                Array.of,
-                chain(assoc('defindex'), compose(
-                    prop('defindex'),//change defindex from unbox skin defindex to weapon defindex
-                    defaultTo({}),
-                    nth(0),
-                    values,
-                    ({ item_name }) => pickBy(allPass([
-                        propEq(6, 'item_quality'),
-                        propEq(item_name, 'item_name')
-                    ]), items),
-                    prop(__, items),
-                    prop('defindex')
-                ))
-            )
-        ]
-    )
-)
+const warPaintRemap = item =>
+    !('texture' in item) && items[item.defindex]?.item_name === 'War Paint'
+        ? { ...item, defindex: '9536' }
+        : item
 
-const warPaintRemap = when(
-    allPass([
-        complement(has)('texture'),
-        compose(
-            propEq('War Paint', 'item_name'),
-            prop(__, items),
-            prop('defindex')
-        ),
-    ]),
-    assoc('defindex', '9536')
-)
+function unboxSkinsRemap(item) {
+    const schemaItem = items[item.defindex]
+    if ('texture' in item || !schemaItem || !('texture' in schemaItem) || schemaItem.item_name === 'War Paint') {
+        return item
+    }
+    const weapon = Object.values(items).find(si => si.item_quality === 6 && si.item_name === schemaItem.item_name)
+    return [item, { ...item, defindex: (weapon ?? {}).defindex }]
+}
 
-const remaps = compose(
-    unboxSkinsRemap,
-    warPaintRemap
-)
+const remaps = item => unboxSkinsRemap(warPaintRemap(item))
 
 const propListDefault = ['killstreakTier', 'elevated', 'festivized', 'effect', 'texture', 'wear', 'craft', 'series']
 
-const blanketify = uncurryN(3, (propList, skus, item) => compose(
-    map(compose(
-        mergeRight(item),//merge the props with the item, keeping the assetid for use later
-        pick(['sku', 'originalSku']),
-        renameKeys({ _sku: 'sku', sku: 'originalSku' })//reset the sku, save the original sku
-    )),
-    filter(compose(includes(__, skus), prop('_sku'))),//find every new combination in the sku list
-    map(chain(assoc('_sku'), skuFromItem)),//save the new sku
-    unnest,
-    map(remaps),//decode defindices that are not possible anymore
-    map(omit(__, itemFromSku(item.sku))),//create items from the combinations
-    //concat([[]]),//create the last combination where no prop is removed. If the skus includes the sku we can return it.
-    chain(compose(getCombos(0), length), identity),//create every possible combination
-    filter(compose(Boolean, prop(__, itemFromSku(item.sku))))//remove every prop from proplist that is not present in the item
-)(propList || propListDefault))
-
-module.exports = {
-    blanketify
-}
+export const blanketify = (skus, propList = propListDefault) => item => {
+    const itemObj = itemFromSku(item.sku)
+    const filteredProps = propList.filter(p => Boolean(itemObj[p]))
+    const combos = getCombos(0, filteredProps.length, filteredProps)
+    return combos
+        .map(combo => Object.fromEntries(Object.entries(itemObj).filter(([k]) => !combo.includes(k))))
+        .flatMap(v => { const r = remaps(v); return Array.isArray(r) ? r : [r] })
+        .map(v => ({ ...v, _sku: skuFromItem(v) }))
+        .filter(v => skus.includes(v._sku))
+        .map(v => ({ ...item, sku: v._sku, originalSku: item.sku }))
+}

package/browser.js

@@ -0,0 +1,13 @@
+import helperObjects from './schemaHelper.json' with { type: 'json' }
+
+export * from './schemaItems.js'
+export * from './sku.js'
+export * from './skuBp.js'
+export * from './skuLinks.js'
+
+export const {
+    qualityNames, qualityIds, rarities, killstreakTiers, wears, classes, itemSlots, itemClasses,
+    paintHex, paintDefindex, spellDefindex, cosmeticCollections, weaponCollections, warPaintCollections,
+    fabricatorDefindex, strangifierTargets, australiumDefindex, crateSeries, paintableDefindex,
+    chemsetDefindex, serieslessDefindex, impossibleEffects
+} = helperObjects

package/fetchAppDataInventory.js

@@ -1,48 +1,49 @@
-const { call, getContext, delay } = require('redux-saga/effects')
+import { call, getContext, delay } from 'redux-saga/effects'
 
-const {
-    groupBy, map, compose, uniq, values, mergeRight, indexBy, props, mapObjIndexed, when, complement, has, assoc, unnest, uncurryN, without
-} = require('ramda')
+const classKey = (classid, instanceid) => `${classid},${instanceid ?? '0'}`
 
 const getAssetClassQuery = assetClassIds => assetClassIds.map(([classid, instanceid], index) => `&classid${index}=${classid}&instanceid${index}=${instanceid}`)
 
-const getAssetClassIds = compose(
-    uniq,
-    map(props(['classid', 'instanceid']))
-)
+function getAssetClassIds(inventory) {
+    const seen = new Set()
+    const result = []
+    for (const item of inventory) {
+        const key = classKey(item.classid, item.instanceid)
+        if (!seen.has(key)) {
+            seen.add(key)
+            result.push([item.classid, item.instanceid])
+        }
+    }
+    return result
+}
 
-const transformAssetClasses = compose(
-    indexBy(props(['classid', 'instanceid'])),
-    map(
-        when(
-            complement(has)('instanceid'),
-            assoc('instanceid', '0')
-        )
-    ),
-    values
-)
+function transformAssetClasses(items) {
+    return Object.fromEntries(
+        Object.values(items)
+            .filter(item => item !== null && typeof item === 'object')
+            .map(item => {
+                const withInstanceId = 'instanceid' in item ? item : { ...item, instanceid: '0' }
+                return [classKey(withInstanceId.classid, withInstanceId.instanceid), withInstanceId]
+            })
+    )
+}
 
-const mergeAssetClasses = uncurryN(2, (assetClasses) => compose(
-    unnest,
-    values,
-    mapObjIndexed((v, k) => map(mergeRight(assetClasses[k]), v)),
-    groupBy(props(['classid', 'instanceid']))
-))
+function mergeAssetClasses(assetClasses, inventory) {
+    const groups = Object.groupBy(inventory, item => classKey(item.classid, item.instanceid))
+    return Object.keys(groups).flatMap(key => groups[key].map(item => ({ ...assetClasses[key], ...item })))
+}
 
-function* fetchAppDataInventory(inventory, d = 1000, cache = []) {
+export function* fetchAppDataInventory(inventory, d = 1000, cache = []) {
     let p = 0, assetClasses = transformAssetClasses(cache)
     const { getAssetClassInfo } = yield getContext('api')
-    const ids = without(cache.map(props(['classid', 'instanceid'])), getAssetClassIds(inventory))
+    const cacheKeys = new Set(cache.map(item => classKey(item.classid, item.instanceid)))
+    const ids = getAssetClassIds(inventory).filter(([classid, instanceid]) => !cacheKeys.has(classKey(classid, instanceid)))
     while (ids.length > 0 && p < ids.length) {
         yield delay(d)
-        const query = getAssetClassQuery(ids.slice(p, p + 150))
+        const query = getAssetClassQuery(ids.slice(p, p + 125))
         const { result } = yield call(getAssetClassInfo, query)
-        assetClasses = mergeRight(assetClasses, transformAssetClasses(result))
-        p += 150
+        assetClasses = { ...assetClasses, ...transformAssetClasses(result) }
+        p += 125
     }
     return mergeAssetClasses(assetClasses, inventory)
 }
-
-module.exports = {
-    fetchAppDataInventory
-}

package/fetchItemsApi.js

@@ -1,23 +1,18 @@
-const { call, delay, getContext } = require('redux-saga/effects')
-const { prop, indexBy, pick, map, compose, evolve, replace, when } = require('ramda')
+import { call, delay, getContext } from 'redux-saga/effects'
 
-const propsToKeep = [
-    'image_url'
-]
+const IMAGE_PREFIX = 'http://media.steampowered.com/apps/440/icons/'
 
-const transformItemsApi = compose(
-    map(
-        compose(
-            pick(propsToKeep),
-            when(
-                prop('image_url'),
-                evolve({ image_url: replace('http://media.steampowered.com/apps/440/icons/', '') })
-            )
-        )),
-    indexBy(prop('defindex'))
-)
+function transformItemsApi(items) {
+    const result = {}
+    for (const item of items) {
+        result[item.defindex] = item.image_url
+            ? { image_url: item.image_url.replace(IMAGE_PREFIX, '') }
+            : {}
+    }
+    return result
+}
 
-function* fetchItemsApi() {
+export function* fetchItemsApi() {
     const { getSchemaItems } = yield getContext('api')
     let start = 0, items = []
     do {
@@ -28,6 +23,3 @@ function* fetchItemsApi() {
     } while (start >= 0)
     return transformItemsApi(items)
 }
-
-
-module.exports = { fetchItemsApi }

package/fetchItemsGame.js

@@ -1,12 +1,13 @@
-const { call, getContext } = require('redux-saga/effects')
+import { call, getContext } from 'redux-saga/effects'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 const vdf = require('vdf')
 
-function* fetchItemsGame() {
+export function* fetchItemsGame() {
     const { getItemsGameUrl, getItemsGame } = yield getContext('api')
     const { result: { items_game_url } } = yield call(getItemsGameUrl)
     const itemsGameVdf = yield call(getItemsGame, items_game_url)
     const { items_game } = vdf.parse(itemsGameVdf)
     return items_game
 }
-
-module.exports = { fetchItemsGame }

package/fetchParticleEffects.js

@@ -1,21 +1,17 @@
-const { call, delay, getContext } = require('redux-saga/effects')
-const { prop, indexBy, map, compose, pickBy, complement, includes, path, nth, invert, invertObj } = require('ramda')
+import { call, getContext } from 'redux-saga/effects'
 
-const transformEffects = compose(
-    invertObj,
-    map(nth(0)),
-    invert,
-    pickBy(Boolean),
-    pickBy(complement(includes)('Attrib_Particle')),
-    map(prop('name')),
-    indexBy(prop('id')),
-    path(['result', 'attribute_controlled_attached_particles'])
-)
+function transformEffects(particles) {
+    const byName = {}
+    for (const { id, name } of particles) {
+        if (name && !name.includes('Attrib_Particle')) {
+            byName[name] ??= id
+        }
+    }
+    return Object.fromEntries(Object.entries(byName).map(([name, id]) => [id, name]))
+}
 
-function* fetchParticleEffects() {
+export function* fetchParticleEffects() {
     const { getSchemaOverview } = yield getContext('api')
     const schema = yield call(getSchemaOverview)
-    return transformEffects(schema)
+    return transformEffects(schema.result.attribute_controlled_attached_particles)
 }
-
-module.exports = { fetchParticleEffects }

package/fetchTextures.js

@@ -1,20 +1,18 @@
-const { call, getContext } = require('redux-saga/effects')
-const vdf = require('vdf')
-
-const { path, compose, pickBy, startsWith, reduce, replace, __, mapKeys } = require('ramda')
-
-const sanitizeTexture = reduce((all, curr) => replace(curr, '', all), __, ['9_', '_field { field_number: 2 }'])
+import { call, getContext } from 'redux-saga/effects'
+import { createRequire } from 'module'
 
-const transformTextures = compose(
-    mapKeys(sanitizeTexture),
-    pickBy((val, key) => startsWith('9', key) && isNaN(val[0])),
-    path(['lang', 'Tokens'])
-)
+const require = createRequire(import.meta.url)
+const vdf = require('vdf')
 
-function* fetchTextures() {
+export function* fetchTextures() {
     const { fetchProtoObjDefs } = yield getContext('api')
     const protoObjDefs = yield call(fetchProtoObjDefs)
-    return transformTextures(vdf.parse(protoObjDefs))
+    const tokens = vdf.parse(protoObjDefs).lang.Tokens
+    const result = {}
+    for (const [key, val] of Object.entries(tokens)) {
+        if (key.startsWith('9') && isNaN(val[0])) {
+            result[key.replace(/^9_/, '').replace('_field { field_number: 2 }', '')] = val
+        }
+    }
+    return result
 }
-
-module.exports = { fetchTextures }

package/fetchTfEnglish.js

@@ -1,12 +1,13 @@
-const { call, getContext } = require('redux-saga/effects')
+import { call, getContext } from 'redux-saga/effects'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 const vdf = require('vdf')
-const { toLower, mapKeys } = require('ramda')
 
-function* fetchTfEnglish() {
-    const { fetchTfEnglish } = yield getContext('api')
-    const english = yield call(fetchTfEnglish)
+export function* fetchTfEnglish() {
+    const { fetchTfEnglish: fetchTfEnglishApi } = yield getContext('api')
+    const english = yield call(fetchTfEnglishApi)
     const englishVdf = vdf.parse(english)
-    return mapKeys(toLower, englishVdf.lang.Tokens)
+    const tokens = englishVdf.lang.Tokens
+    return Object.fromEntries(Object.entries(tokens).map(([k, v]) => [k.toLowerCase(), v]))
 }
-
-module.exports = { fetchTfEnglish }