@juice789/tf2items 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+sku playground: https://juice789.github.io/tf2items/
+
+todo readme

package/api.js

@@ -0,0 +1,59 @@
+const axios = require('axios')
+const { compose, __, map, applyTo, prop } = require('ramda')
+
+const myAxios = axios.create()
+
+myAxios.interceptors.response.use(prop('data'), Promise.reject.bind(Promise))
+
+const api = {}
+
+api.getSchemaItems = ({ steamApiKey: key }) => (start) => myAxios({
+    method: 'get',
+    url: 'https://api.steampowered.com/IEconItems_440/GetSchemaItems/v1/',
+    params: {
+        key,
+        language: 'EN',
+        start
+    }
+})
+
+api.getSchemaOverview = ({ steamApiKey: key }) => () => myAxios({
+    method: 'get',
+    url: 'https://api.steampowered.com/IEconItems_440/GetSchemaOverview/v1/',
+    params: {
+        key,
+        language: 'EN'
+    }
+})
+
+api.getItemsGameUrl = ({ steamApiKey: key }) => () => myAxios({
+    method: 'get',
+    url: 'https://api.steampowered.com/IEconItems_440/GetSchemaURL/v1/',
+    params: {
+        key
+    }
+})
+
+api.getItemsGame = () => (url) => myAxios({
+    method: 'get',
+    url
+})
+
+api.fetchTfEnglish = () => () => myAxios({
+    method: 'get',
+    url: 'https://raw.githubusercontent.com/SteamDatabase/GameTracking-TF2/master/tf/resource/tf_english.txt'
+})
+
+api.fetchProtoObjDefs = () => () => myAxios({
+    method: 'get',
+    url: 'https://raw.githubusercontent.com/SteamDatabase/GameTracking-TF2/master/tf/resource/tf_proto_obj_defs_english.txt'
+})
+
+api.getAssetClassInfo = ({ steamApiKey }) => (ids, appId = 440) => myAxios({
+    method: 'get',
+    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

package/app.js

@@ -0,0 +1,42 @@
+const { runSaga } = require('redux-saga')
+const { map, compose, replace } = require('ramda')
+const { renameKeysWith } = require('ramda-adjunct')
+
+const helperObjects = require('./schemaHelper.json')
+const sagaHelpers = require('./sagaHelpers')
+
+const items = require('./schemaItems.js')
+const sku = require('./sku.js')
+const skuBp = require('./skuBp.js')
+
+const createApi = require('./api.js')
+
+const sagas = require('./sagas.js')
+const { saveSchemaSaga } = require('./saveSchema.js')
+
+const getInstance = (options) => {
+    const api = createApi(options)
+    return compose(
+        renameKeysWith(replace('Saga', '')),
+        map(
+            (saga) => (...args) => new Promise((resolve, reject) => {
+                runSaga({
+                    context: { api }
+                }, saga, ...args)
+                    .toPromise()
+                    .then(resolve, reject)
+            })
+        ),
+    )({ ...sagas, saveSchemaSaga })
+}
+
+module.exports = {
+    ...helperObjects,
+    ...items,
+    ...sku,
+    ...skuBp,
+    ...sagas,
+    ...sagaHelpers,
+    saveSchemaSaga,
+    getInstance
+}

package/blanket.js

@@ -0,0 +1,119 @@
+const {
+    defaultTo,
+    nth,
+    compose,
+    length,
+    prop,
+    map,
+    uncurryN,
+    values,
+    when,
+    includes,
+    __,
+    propEq,
+    identity,
+    filter,
+    assoc,
+    chain,
+    omit,
+    pickBy,
+    has,
+    complement,
+    allPass,
+    converge,
+    concat,
+    of,
+    unnest,
+    pick
+} = require('ramda')
+const { renameKeys } = require('ramda-adjunct')
+
+const { safeItems: items } = require('./schemaItems.js')
+const { skuFromItem, itemFromSku } = require('./sku.js')
+
+const choose = (n, xs) =>
+    n < 1 || n > xs.length
+        ? []
+        : 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)]
+)
+
+const unboxSkinsRemap = when(
+    allPass([
+        complement(has)('texture'),//no texture
+        compose(//is an unbox skin
+            allPass([
+                has('texture'),
+                complement(propEq)('item_name', 'War Paint')
+            ]),
+            prop(__, items),
+            prop('defindex')
+        )
+    ]),
+    converge(
+        concat,
+        [
+            of,
+            compose(
+                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('item_quality', 6),
+                        propEq('item_name', item_name)
+                    ]), items),
+                    prop(__, items),
+                    prop('defindex')
+                ))
+            )
+        ]
+    )
+)
+
+const warPaintRemap = when(
+    allPass([
+        complement(has)('texture'),
+        compose(
+            propEq('item_name', 'War Paint'),
+            prop(__, items),
+            prop('defindex')
+        ),
+    ]),
+    assoc('defindex', '9536')
+)
+
+const remaps = compose(
+    unboxSkinsRemap,
+    warPaintRemap
+)
+
+const propListDefault = ['killstreakTier', 'elevated', 'festivized', 'effect', 'texture', 'wear', 'craft', 'series']
+
+const blanketify = uncurryN(3, (propList, skus, sku) => compose(
+    map(pick(['sku', 'originalSku'])),
+    map(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(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(sku))))//remove every prop from proplist that is not present in the item
+)(propList || propListDefault))
+
+module.exports = {
+    blanketify
+}

package/fetchAppDataInventory.js

@@ -0,0 +1,54 @@
+const { call, getContext, delay } = require('redux-saga/effects')
+
+const {
+    groupBy, map, compose, toPairs, uniq, pick, values, mergeRight, indexBy, props, mapObjIndexed, when, complement, has, assoc, unnest, uncurryN
+} = require('ramda')
+
+const getAssetClassQuery = compose(
+    map(([key, { classid, instanceid }]) => `&classid${key}=${classid}&instanceid${key}=${instanceid}`),
+    toPairs
+)
+
+const getAssetClassIds = compose(
+    uniq,
+    map(pick(['classid', 'instanceid']))
+)
+
+const transformAssetClasses = compose(
+    indexBy(props(['classid', 'instanceid'])),
+    map(
+        when(
+            complement(has)('instanceid'),
+            assoc('instanceid', '0')
+        )
+    ),
+    values
+)
+
+const mergeAssetClasses = uncurryN(2, (assetClasses) => compose(
+    unnest,
+    values,
+    mapObjIndexed((v, k) => map(mergeRight(assetClasses[k]), v)),
+    groupBy(props(['classid', 'instanceid']))
+))
+
+function* fetchAppDataInventory(inventory, d = 1000) {
+
+    let p = 0, assetClasses = {}
+    const { getAssetClassInfo } = yield getContext('api')
+    const ids = getAssetClassIds(inventory)
+
+    while (ids.length > 0 && p < ids.length) {
+        yield delay(d)
+        const query = getAssetClassQuery(ids.slice(p, p + 100))
+        const { result } = yield call(getAssetClassInfo, query)
+        assetClasses = mergeRight(assetClasses, transformAssetClasses(result))
+        p += 100
+    }
+
+    return mergeAssetClasses(assetClasses, inventory)
+}
+
+module.exports = {
+    fetchAppDataInventory
+}

package/fetchItemsApi.js

@@ -0,0 +1,33 @@
+const { call, delay, getContext } = require('redux-saga/effects')
+const { prop, indexBy, pick, map, compose, evolve, replace, when } = require('ramda')
+
+const propsToKeep = [
+    'image_url'
+]
+
+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* fetchItemsApiSaga() {
+    const { getSchemaItems } = yield getContext('api')
+    let start = 0, items = []
+    do {
+        yield delay(1000)
+        const response = yield call(getSchemaItems, start)
+        items = items.concat(response.result.items)
+        start = response.result.next
+    } while (start >= 0)
+    return transformItemsApi(items)
+}
+
+
+module.exports = { fetchItemsApiSaga }

package/fetchItemsGame.js

@@ -0,0 +1,12 @@
+const { call, getContext } = require('redux-saga/effects')
+const vdf = require('vdf')
+
+function* fetchItemsGameSaga() {
+    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 = { fetchItemsGameSaga }

package/fetchParticleEffects.js

@@ -0,0 +1,20 @@
+const { call, delay, getContext } = require('redux-saga/effects')
+const { prop, indexBy, map, compose, pickBy, complement, includes, path, nth, invert, invertObj } = require('ramda')
+
+const transformEffects = compose(
+    invertObj,
+    map(nth(0)),
+    invert,
+    pickBy(complement(includes)('Attrib_Particle')),
+    map(prop('name')),
+    indexBy(prop('id')),
+    path(['result', 'attribute_controlled_attached_particles'])
+)
+
+function* fetchParticleEffectsSaga() {
+    const { getSchemaOverview } = yield getContext('api')
+    const schema = yield call(getSchemaOverview)
+    return transformEffects(schema)
+}
+
+module.exports = { fetchParticleEffectsSaga }

package/fetchTextures.js

@@ -0,0 +1,21 @@
+const { call, getContext } = require('redux-saga/effects')
+const vdf = require('vdf')
+
+const { path, compose, pickBy, startsWith, reduce, replace, __ } = require('ramda')
+const { renameKeysWith } = require('ramda-adjunct')
+
+const sanitizeTexture = reduce((all, curr) => replace(curr, '', all), __, ['9_', '_field { field_number: 2 }'])
+
+const transformTextures = compose(
+    renameKeysWith(sanitizeTexture),
+    pickBy((val, key) => startsWith('9', key) && isNaN(val[0])),
+    path(['lang', 'Tokens'])
+)
+
+function* fetchTexturesSaga() {
+    const { fetchProtoObjDefs } = yield getContext('api')
+    const protoObjDefs = yield call(fetchProtoObjDefs)
+    return transformTextures(vdf.parse(protoObjDefs))
+}
+
+module.exports = { fetchTexturesSaga }

package/fetchTfEnglish.js

@@ -0,0 +1,13 @@
+const { call, getContext } = require('redux-saga/effects')
+const vdf = require('vdf')
+const { toLower } = require('ramda')
+const { renameKeysWith } = require('ramda-adjunct')
+
+function* fetchTfEnglishSaga() {
+    const { fetchTfEnglish } = yield getContext('api')
+    const english = yield call(fetchTfEnglish)
+    const englishVdf = vdf.parse(english)
+    return renameKeysWith(toLower, englishVdf.lang.Tokens)
+}
+
+module.exports = { fetchTfEnglishSaga }