@ianlucas/cs2-lib-inspect 1.0.0

package/License.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 candyboyz
+Copyright (c) 2024-present Ian Lucas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# cs2-lib-inspect
+
+> A utility for creating inspect links for CS2 items
+
+## Install
+
+```bash
+npm install @ianlucas/cs2-lib-inspect
+```
+
+## Usage
+
+```typescript
+import { CS_Economy } from "@ianlucas/cs2-lib";
+import { CS_generateInspectLink } from "@ianlucas/cs2-lib-inspect";
+
+const link = CS_generateInspectLink(CS_Economy.getById(307));
+```

package/dist/esm/index.js

@@ -0,0 +1,560 @@
+// src/index.ts
+import {
+  CS_Economy,
+  CS_MIN_SEED,
+  CS_MIN_STICKER_WEAR,
+  CS_MIN_WEAR,
+  CS_NONE,
+  CS_RARITY_ANCIENT_COLOR,
+  CS_RARITY_COMMON_COLOR,
+  CS_RARITY_IMMORTAL_COLOR,
+  CS_RARITY_LEGENDARY_COLOR,
+  CS_RARITY_MYTHICAL_COLOR,
+  CS_RARITY_RARE_COLOR,
+  CS_RARITY_UNCOMMON_COLOR
+} from "@ianlucas/cs2-lib";
+import { Buffer } from "buffer";
+import CRC32 from "crc-32";
+
+// src/econ.ts
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+var CEconItemPreviewDataBlock$Type = class extends MessageType {
+  constructor() {
+    super("CEconItemPreviewDataBlock", [
+      {
+        no: 1,
+        name: "accountid",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 2,
+        name: "itemid",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+      },
+      {
+        no: 3,
+        name: "defindex",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 4,
+        name: "paintindex",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 5,
+        name: "rarity",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 6,
+        name: "quality",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 7,
+        name: "paintwear",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 8,
+        name: "paintseed",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 9,
+        name: "killeaterscoretype",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 10,
+        name: "killeatervalue",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 11,
+        name: "customname",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 12,
+        name: "stickers",
+        kind: "message",
+        repeat: 1,
+        T: () => CEconItemPreviewDataBlock_Sticker
+      },
+      {
+        no: 13,
+        name: "inventory",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 14,
+        name: "origin",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 15,
+        name: "questid",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 16,
+        name: "dropreason",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 17,
+        name: "musicindex",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 18,
+        name: "entindex",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.stickers = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional uint32 accountid */
+        1:
+          message.accountid = reader.uint32();
+          break;
+        case /* optional uint64 itemid */
+        2:
+          message.itemid = reader.uint64().toBigInt();
+          break;
+        case /* optional uint32 defindex */
+        3:
+          message.defindex = reader.uint32();
+          break;
+        case /* optional uint32 paintindex */
+        4:
+          message.paintindex = reader.uint32();
+          break;
+        case /* optional uint32 rarity */
+        5:
+          message.rarity = reader.uint32();
+          break;
+        case /* optional uint32 quality */
+        6:
+          message.quality = reader.uint32();
+          break;
+        case /* optional uint32 paintwear */
+        7:
+          message.paintwear = reader.uint32();
+          break;
+        case /* optional uint32 paintseed */
+        8:
+          message.paintseed = reader.uint32();
+          break;
+        case /* optional uint32 killeaterscoretype */
+        9:
+          message.killeaterscoretype = reader.uint32();
+          break;
+        case /* optional uint32 killeatervalue */
+        10:
+          message.killeatervalue = reader.uint32();
+          break;
+        case /* optional string customname */
+        11:
+          message.customname = reader.string();
+          break;
+        case /* repeated CEconItemPreviewDataBlock.Sticker stickers */
+        12:
+          message.stickers.push(
+            CEconItemPreviewDataBlock_Sticker.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options
+            )
+          );
+          break;
+        case /* optional uint32 inventory */
+        13:
+          message.inventory = reader.uint32();
+          break;
+        case /* optional uint32 origin */
+        14:
+          message.origin = reader.uint32();
+          break;
+        case /* optional uint32 questid */
+        15:
+          message.questid = reader.uint32();
+          break;
+        case /* optional uint32 dropreason */
+        16:
+          message.dropreason = reader.uint32();
+          break;
+        case /* optional uint32 musicindex */
+        17:
+          message.musicindex = reader.uint32();
+          break;
+        case /* optional int32 entindex */
+        18:
+          message.entindex = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.accountid !== void 0)
+      writer.tag(1, WireType.Varint).uint32(message.accountid);
+    if (message.itemid !== void 0)
+      writer.tag(2, WireType.Varint).uint64(message.itemid);
+    if (message.defindex !== void 0)
+      writer.tag(3, WireType.Varint).uint32(message.defindex);
+    if (message.paintindex !== void 0)
+      writer.tag(4, WireType.Varint).uint32(message.paintindex);
+    if (message.rarity !== void 0)
+      writer.tag(5, WireType.Varint).uint32(message.rarity);
+    if (message.quality !== void 0)
+      writer.tag(6, WireType.Varint).uint32(message.quality);
+    if (message.paintwear !== void 0)
+      writer.tag(7, WireType.Varint).uint32(message.paintwear);
+    if (message.paintseed !== void 0)
+      writer.tag(8, WireType.Varint).uint32(message.paintseed);
+    if (message.killeaterscoretype !== void 0)
+      writer.tag(9, WireType.Varint).uint32(message.killeaterscoretype);
+    if (message.killeatervalue !== void 0)
+      writer.tag(10, WireType.Varint).uint32(message.killeatervalue);
+    if (message.customname !== void 0)
+      writer.tag(11, WireType.LengthDelimited).string(message.customname);
+    for (let i = 0; i < message.stickers.length; i++)
+      CEconItemPreviewDataBlock_Sticker.internalBinaryWrite(
+        message.stickers[i],
+        writer.tag(12, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.inventory !== void 0)
+      writer.tag(13, WireType.Varint).uint32(message.inventory);
+    if (message.origin !== void 0)
+      writer.tag(14, WireType.Varint).uint32(message.origin);
+    if (message.questid !== void 0)
+      writer.tag(15, WireType.Varint).uint32(message.questid);
+    if (message.dropreason !== void 0)
+      writer.tag(16, WireType.Varint).uint32(message.dropreason);
+    if (message.musicindex !== void 0)
+      writer.tag(17, WireType.Varint).uint32(message.musicindex);
+    if (message.entindex !== void 0)
+      writer.tag(18, WireType.Varint).int32(message.entindex);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+};
+var CEconItemPreviewDataBlock = new CEconItemPreviewDataBlock$Type();
+var CEconItemPreviewDataBlock_Sticker$Type = class extends MessageType {
+  constructor() {
+    super("CEconItemPreviewDataBlock.Sticker", [
+      {
+        no: 1,
+        name: "slot",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 2,
+        name: "sticker_id",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 3,
+        name: "wear",
+        kind: "scalar",
+        opt: true,
+        T: 2
+      },
+      {
+        no: 4,
+        name: "scale",
+        kind: "scalar",
+        opt: true,
+        T: 2
+      },
+      {
+        no: 5,
+        name: "rotation",
+        kind: "scalar",
+        opt: true,
+        T: 2
+      },
+      {
+        no: 6,
+        name: "tint_id",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 7,
+        name: "offset_x",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 8,
+        name: "offset_y",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      reflectionMergePartial(
+        this,
+        message,
+        value
+      );
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* optional uint32 slot */
+        1:
+          message.slot = reader.uint32();
+          break;
+        case /* optional uint32 sticker_id */
+        2:
+          message.stickerId = reader.uint32();
+          break;
+        case /* optional float wear */
+        3:
+          message.wear = reader.float();
+          break;
+        case /* optional float scale */
+        4:
+          message.scale = reader.float();
+          break;
+        case /* optional float rotation */
+        5:
+          message.rotation = reader.float();
+          break;
+        case /* optional uint32 tint_id */
+        6:
+          message.tintId = reader.uint32();
+          break;
+        case /* optional uint32 offset_x */
+        7:
+          message.offsetX = reader.uint32();
+          break;
+        case /* optional uint32 offset_y */
+        8:
+          message.offsetY = reader.uint32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.slot !== void 0)
+      writer.tag(1, WireType.Varint).uint32(message.slot);
+    if (message.stickerId !== void 0)
+      writer.tag(2, WireType.Varint).uint32(message.stickerId);
+    if (message.wear !== void 0)
+      writer.tag(3, WireType.Bit32).float(message.wear);
+    if (message.scale !== void 0)
+      writer.tag(4, WireType.Bit32).float(message.scale);
+    if (message.rotation !== void 0)
+      writer.tag(5, WireType.Bit32).float(message.rotation);
+    if (message.tintId !== void 0)
+      writer.tag(6, WireType.Varint).uint32(message.tintId);
+    if (message.offsetX !== void 0)
+      writer.tag(7, WireType.Varint).uint32(message.offsetX);
+    if (message.offsetY !== void 0)
+      writer.tag(8, WireType.Varint).uint32(message.offsetY);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+};
+var CEconItemPreviewDataBlock_Sticker = new CEconItemPreviewDataBlock_Sticker$Type();
+
+// src/index.ts
+var CS_RARITY_INT = {
+  [CS_RARITY_COMMON_COLOR]: 1,
+  [CS_RARITY_UNCOMMON_COLOR]: 2,
+  [CS_RARITY_RARE_COLOR]: 3,
+  [CS_RARITY_MYTHICAL_COLOR]: 4,
+  [CS_RARITY_LEGENDARY_COLOR]: 5,
+  [CS_RARITY_ANCIENT_COLOR]: 6,
+  [CS_RARITY_IMMORTAL_COLOR]: 7
+};
+var MISSING_ITEM_DEF = {
+  graffiti: 1348,
+  patch: 4609,
+  sticker: 1209,
+  musickit: 1314
+};
+var CS_PREVIEW_URL = "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20";
+function floatToBytes(floatValue) {
+  const floatArray = new Float32Array(1);
+  floatArray[0] = floatValue;
+  const byteArray = new Uint32Array(floatArray.buffer);
+  return byteArray[0];
+}
+function getItemAttributes(item) {
+  const { def, index, rarity, type, tint, wearmin } = item;
+  const hasStickerObject = MISSING_ITEM_DEF[type] !== void 0;
+  const hasPaintIndex = !hasStickerObject && type !== "musickit";
+  return {
+    defindex: MISSING_ITEM_DEF[type] ?? def,
+    musicindex: type === "musickit" ? index : void 0,
+    paintindex: hasPaintIndex ? index : void 0,
+    paintseed: CS_Economy.hasSeed(item) ? CS_MIN_SEED : void 0,
+    paintwear: CS_Economy.hasWear(item) ? wearmin ?? CS_MIN_WEAR : void 0,
+    rarity: CS_RARITY_INT[rarity] ?? 0,
+    stickers: hasStickerObject ? [
+      {
+        tintId: tint,
+        stickerId: index,
+        slot: 0
+      }
+    ] : []
+  };
+}
+function getBaseInventoryItemAttributes({
+  id,
+  nametag,
+  seed,
+  stattrak,
+  stickers,
+  stickerswear,
+  wear
+}) {
+  const item = CS_Economy.getById(id);
+  const baseAttributes = getItemAttributes(item);
+  return {
+    ...baseAttributes,
+    customname: nametag,
+    killeaterscoretype: stattrak !== void 0 ? 0 : void 0,
+    killeatervalue: stattrak,
+    paintseed: CS_Economy.hasSeed(item) ? seed ?? CS_MIN_SEED : void 0,
+    paintwear: CS_Economy.hasWear(item) ? floatToBytes(wear ?? item.wearmin ?? CS_MIN_WEAR) : void 0,
+    stickers: stickers !== void 0 ? stickers.map((sticker, slot) => ({
+      slot,
+      stickerId: CS_Economy.getById(sticker).index,
+      wear: stickerswear?.[slot] ?? CS_MIN_STICKER_WEAR
+    })).filter(({ stickerId }) => stickerId !== CS_NONE) : baseAttributes.stickers
+  };
+}
+function generateHex(attributes) {
+  console.log(attributes);
+  const payload = Buffer.concat([Uint8Array.from([0]), CEconItemPreviewDataBlock.toBinary(attributes)]);
+  const crc = CRC32.buf(payload);
+  const xCrc = crc & 65535 ^ CEconItemPreviewDataBlock.toBinary(attributes).byteLength * crc;
+  const crcBuffer = Buffer.alloc(4);
+  crcBuffer.writeUInt32BE((xCrc & 4294967295) >>> 0, 0);
+  const buffer = Buffer.concat([payload, crcBuffer]);
+  return buffer.toString("hex").toUpperCase();
+}
+function CS_generateInspectLink(item) {
+  const econ = {
+    ...typeof item.uid === void 0 ? getItemAttributes(item) : getBaseInventoryItemAttributes(item)
+  };
+  return `${CS_PREVIEW_URL}${generateHex(econ)}`;
+}
+export {
+  CS_PREVIEW_URL,
+  CS_generateInspectLink
+};

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { CS_Item, CS_BaseInventoryItem, CS_InventoryItem } from '@ianlucas/cs2-lib';
+
+declare const CS_PREVIEW_URL = "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20";
+declare function CS_generateInspectLink(item: CS_Item | CS_BaseInventoryItem | CS_InventoryItem): string;
+
+export { CS_PREVIEW_URL, CS_generateInspectLink };

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@ianlucas/cs2-lib-inspect",
+    "version": "1.0.0",
+    "description": "A utility for creating inspect links for CS2 items",
+    "license": "MIT",
+    "repository": "ianlucas/cs2-lib-inspect",
+    "main": "dist/esm/index.js",
+    "types": "dist/index.d.mts",
+    "files": [
+        "dist/**/*"
+    ],
+    "scripts": {
+        "format": "prettier . --write",
+        "prepack": "tsup --legacy-output",
+        "protoc": "npx protoc --ts_out src --proto_path protos protos/econ.proto",
+        "test": "jest"
+    },
+    "dependencies": {
+        "@protobuf-ts/runtime": "^2.9.4",
+        "buffer": "^6.0.3",
+        "crc-32": "^1.2.2"
+    },
+    "peerDependencies": {
+        "@ianlucas/cs2-lib": "^4.5.0"
+    },
+    "devDependencies": {
+        "@protobuf-ts/plugin": "^2.9.3",
+        "prettier": "^3.2.5",
+        "tsup": "^8.0.1",
+        "typescript": "^5.3.3"
+    }
+}