ya-struct 0.0.5 → 0.0.6

package/lib/types/index.ts

@@ -0,0 +1,122 @@
+import type { TAbi } from "../common.ts";
+
+type TCFieldType =
+  "char" | "unsigned char" |
+  "short" | "unsigned short" |
+  "int" | "unsigned int" |
+  "long" | "unsigned long" |
+  "long long" | "unsigned long long" |
+  "float" | "double" | "long double";
+
+type TFieldType = {
+  readonly type: "integer";
+  readonly sizeInBits: number;
+  readonly signed: boolean;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "float";
+  readonly sizeInBits: number;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "pointer";
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "array";
+  readonly elementType: TFieldType;
+  readonly length: number;
+} | {
+  readonly type: "struct";
+  readonly fields: readonly { readonly name: string; readonly definition: TFieldType }[];
+  readonly packed: boolean;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "string";
+  readonly charSizeInBits: number;
+  readonly nullTerminatorMandatory: boolean;
+  readonly length: number;
+} | {
+  readonly type: "c-type";
+  readonly cType: TCFieldType;
+  readonly fixedAbi: Partial<TAbi>;
+};
+
+type TBasicFieldType = Exclude<TFieldType, { type: "c-type" }>;
+type TPrimitiveBasicFieldType = Exclude<TBasicFieldType, { type: "array" } | { type: "struct" } | { type: "string" }>;
+
+const Int16: TFieldType = {
+  type: "integer",
+  sizeInBits: 16,
+  signed: true,
+  fixedAbi: {}
+} as const;
+
+const UInt16: TFieldType = {
+  type: "integer",
+  sizeInBits: 16,
+  signed: false,
+  fixedAbi: {}
+} as const;
+
+const Int32: TFieldType = {
+  type: "integer",
+  sizeInBits: 32,
+  signed: true,
+  fixedAbi: {}
+} as const;
+
+const Int64: TFieldType = {
+  type: "integer",
+  sizeInBits: 64,
+  signed: true,
+  fixedAbi: {}
+} as const;
+
+const UInt32: TFieldType = {
+  type: "integer",
+  sizeInBits: 32,
+  signed: false,
+  fixedAbi: {}
+} as const;
+
+const UInt64: TFieldType = {
+  type: "integer",
+  sizeInBits: 64,
+  signed: false,
+  fixedAbi: {}
+} as const;
+
+const ascii = ({ length }: { length: number }): TFieldType => {
+  return {
+    type: "string",
+    charSizeInBits: 8,
+    nullTerminatorMandatory: true,
+    length
+  } as const;
+};
+
+const pointer: TFieldType = {
+  type: "pointer",
+  fixedAbi: {}
+} as const;
+
+export type {
+  TBasicFieldType,
+  TFieldType,
+  TCFieldType,
+  TPrimitiveBasicFieldType
+};
+
+const types = {
+  Int16,
+  UInt16,
+  Int32,
+  Int64,
+  UInt32,
+  UInt64,
+  ascii,
+  pointer
+} as const;
+
+export {
+  types
+};

package/lib/types/integer.ts

@@ -0,0 +1,160 @@
+import type { TEndianness } from "../common.ts";
+import type { TValueParser } from "./value.ts";
+
+type TIntegerParser = TValueParser<bigint>;
+
+const createIntegerParser = ({
+  sizeInBits,
+  signed,
+  endianness
+}: {
+  sizeInBits: number,
+  signed: boolean,
+  endianness: TEndianness
+}): TIntegerParser => {
+
+  // eslint-disable-next-line max-statements, complexity
+  const parse: TIntegerParser["parse"] = ({ data, offsetInBits }) => {
+    if (data.length < sizeInBits / 8) {
+      throw Error("BUG: not enough data for integer parsing");
+    }
+
+    if (offsetInBits !== 0) {
+      throw Error("unaligned data in integer parser, not supported yet");
+    }
+
+    const view = new DataView(data.buffer, data.byteOffset);
+
+    if (sizeInBits === 8) {
+      if (signed) {
+        return BigInt(view.getInt8(0));
+      } else {
+        return BigInt(view.getUint8(0));
+      }
+    } else if (sizeInBits === 16) {
+      if (signed) {
+        if (endianness === "little") {
+          return BigInt(view.getInt16(0, true));
+        } else {
+          return BigInt(view.getInt16(0, false));
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          return BigInt(view.getUint16(0, true));
+        } else {
+          return BigInt(view.getUint16(0, false));
+        }
+      }
+    } else if (sizeInBits === 32) {
+      if (signed) {
+        if (endianness === "little") {
+          return BigInt(view.getInt32(0, true));
+        } else {
+          return BigInt(view.getInt32(0, false));
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          return BigInt(view.getUint32(0, true));
+        } else {
+          return BigInt(view.getUint32(0, false));
+        }
+      }
+    } else if (sizeInBits === 64) {
+      if (signed) {
+        if (endianness === "little") {
+          return view.getBigInt64(0, true);
+        } else {
+          return view.getBigInt64(0, false);
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          return view.getBigUint64(0, true);
+        } else {
+          return view.getBigUint64(0, false);
+        }
+      }
+    }
+
+    throw Error("not implemented yet");
+  };
+
+  // eslint-disable-next-line max-statements, complexity
+  const format: TIntegerParser["format"] = ({ value, target, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned data in integer formatter, not supported yet");
+    }
+
+    if (typeof value !== "bigint") {
+      throw Error("invalid value type for integer formatter");
+    }
+
+    const view = new DataView(target.buffer, target.byteOffset);
+
+    if (sizeInBits === 8) {
+      if (signed) {
+        view.setInt8(0, Number(value));
+      } else {
+        view.setUint8(0, Number(value));
+      }
+    } else if (sizeInBits === 16) {
+      if (signed) {
+        if (endianness === "little") {
+          view.setInt16(0, Number(value), true);
+        } else {
+          view.setInt16(0, Number(value), false);
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          view.setUint16(0, Number(value), true);
+        } else {
+          view.setUint16(0, Number(value), false);
+        }
+      }
+    } else if (sizeInBits === 32) {
+      if (signed) {
+        if (endianness === "little") {
+          view.setInt32(0, Number(value), true);
+        } else {
+          view.setInt32(0, Number(value), false);
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          view.setUint32(0, Number(value), true);
+        } else {
+          view.setUint32(0, Number(value), false);
+        }
+      }
+    } else if (sizeInBits === 64) {
+      if (signed) {
+        if (endianness === "little") {
+          view.setBigInt64(0, value, true);
+        } else {
+          view.setBigInt64(0, value, false);
+        }
+      } else {
+        // eslint-disable-next-line no-lonely-if
+        if (endianness === "little") {
+          view.setBigUint64(0, value, true);
+        } else {
+          view.setBigUint64(0, value, false);
+        }
+      }
+    } else {
+      throw Error("not implemented yet");
+    }
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createIntegerParser
+};

package/lib/types/pointer.ts

@@ -0,0 +1,27 @@
+import type { TEndianness } from "../common.ts";
+import { createIntegerParser } from "./integer.ts";
+import type { TValueParser } from "./value.ts";
+
+type TPointerParser = TValueParser<bigint>;
+
+const createPointerParser = ({ sizeInBits, endianness }: { sizeInBits: number, endianness: TEndianness }): TPointerParser => {
+
+  const integerParser = createIntegerParser({ sizeInBits, signed: false, endianness });
+
+  const parse: TPointerParser["parse"] = ({ data, offsetInBits }) => {
+    return integerParser.parse({ data, offsetInBits });
+  };
+
+  const format: TPointerParser["format"] = ({ value, target, offsetInBits }) => {
+    return integerParser.format({ value, target, offsetInBits });
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createPointerParser
+};

package/lib/types/string.ts

@@ -0,0 +1,56 @@
+import type { TValueParser } from "./value.ts";
+
+type TStringParser = TValueParser<string>;
+
+const createStringParser = ({ length }: { length: number }): TStringParser => {
+
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+
+  const parse: TStringParser["parse"] = ({ data, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned data in string parser, not supported yet");
+    }
+
+    if (data.length < length) {
+      throw Error("not enough data for string parsing");
+    }
+
+    const stringData = data.subarray(0, length);
+    const nullTerminatorIndex = stringData.indexOf(0);
+
+    if (nullTerminatorIndex < 0) {
+      return decoder.decode(stringData);
+    }
+
+    return decoder.decode(stringData.subarray(0, nullTerminatorIndex));
+  };
+
+  const format: TStringParser["format"] = ({ value, target, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned data in string formatter, not supported yet");
+    }
+
+    if (target.length < length) {
+      throw Error("not enough space in target for string formatting");
+    }
+
+    const encoded = encoder.encode(value);
+
+    if (encoded.length + 1 >= length) {
+      throw Error("string too long to fit in target");
+    }
+
+    target.set(encoded, 0);
+    target[encoded.length] = 0;
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createStringParser
+};

package/lib/types/struct.ts

@@ -0,0 +1,113 @@
+import type { TEndianness } from "../common.ts";
+import type { TLayoutedField } from "../layout.ts";
+import { createIntegerParser } from "./integer.ts";
+import { createPointerParser } from "./pointer.ts";
+import { createStringParser } from "./string.ts";
+import { createArrayParser } from "./array.ts";
+import type { TValueParser } from "./value.ts";
+import type { TFieldType } from "./index.ts";
+
+type TStructParser = TValueParser<Record<string, unknown>>;
+
+const createStructParser = ({
+  layoutedFields,
+  endianness
+}: {
+  layoutedFields: (TLayoutedField & { type: "struct" })["fields"];
+  endianness: TEndianness
+}): TStructParser => {
+
+  // eslint-disable-next-line complexity, @typescript-eslint/no-explicit-any
+  const fieldParsers: TValueParser<any>[] = layoutedFields.map((field) => {
+    if (field.definition.type === "integer") {
+      return createIntegerParser({
+        sizeInBits: field.definition.sizeInBits,
+        signed: field.definition.signed,
+        endianness
+      });
+    }
+
+    if (field.definition.type === "pointer") {
+      return createPointerParser({
+        sizeInBits: field.definition.sizeInBits,
+        endianness
+      });
+    }
+
+    if (field.definition.type === "struct") {
+      return createStructParser({
+        layoutedFields: field.definition.fields,
+        endianness
+      });
+    }
+
+    if (field.definition.type === "string") {
+      return createStringParser({
+        length: field.definition.length,
+      });
+    }
+
+    if (field.definition.type === "array") {
+      return createArrayParser({
+        // TODO: cast should not be necessary
+        elementType: field.definition.elementType as TFieldType,
+        endianness,
+        length: field.definition.length
+      });
+    }
+
+    throw Error("not implemented yet");
+  });
+
+  const parse: TStructParser["parse"] = ({ data, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned struct parsing not supported yet");
+    }
+
+    // eslint-disable-next-line prefer-const
+    let result: Record<string, unknown> = {};
+
+    layoutedFields.forEach((field, idx) => {
+      const fieldParser = fieldParsers[idx];
+
+      const offsetInBitsInByte = field.definition.offsetInBits % 8;
+      if (offsetInBitsInByte !== 0) {
+        throw Error("not implemented yet: unaligned field parsing");
+      }
+
+      const fieldData = new Uint8Array(data.buffer, data.byteOffset + (field.definition.offsetInBits / 8));
+      result[field.name] = fieldParser.parse({ data: fieldData, offsetInBits: offsetInBitsInByte });
+    });
+
+    return result;
+  };
+
+  const format: TStructParser["format"] = ({ value, target, offsetInBits }) => {
+    layoutedFields.forEach((field, idx) => {
+      const fieldValue = value[field.name];
+      const fieldParser = fieldParsers[idx];
+
+      const offsetInBitsInByte = field.definition.offsetInBits % 8;
+      if (offsetInBitsInByte !== 0) {
+        throw Error("not implemented yet: unaligned field formatting");
+      }
+
+      const fieldTarget = new Uint8Array(target.buffer, target.byteOffset + (field.definition.offsetInBits / 8));
+
+      try {
+        fieldParser.format({ value: fieldValue, target: fieldTarget, offsetInBits });
+      } catch (ex) {
+        throw Error(`failed to format field "${field.name}"`, { cause: ex });
+      }
+    });
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createStructParser
+};

package/lib/types/value.ts

@@ -0,0 +1,8 @@
+type TValueParser<T> = {
+  parse: ({ data }: { data: Uint8Array, offsetInBits: number }) => T;
+  format: ({ value, target }: { value: T, target: Uint8Array, offsetInBits: number }) => void;
+};
+
+export type {
+  TValueParser
+};

package/package.json

@@ -1,12 +1,26 @@
 {
+  "version": "0.0.6",
   "name": "ya-struct",
   "type": "module",
-  "version": "0.0.5",
   "description": "Yet Another Node.js Structure API",
-  "main": "lib/index.js",
+  "main": "dist/lib/index.js",
   "scripts": {
-    "test": "c8 --reporter lcov --reporter html --reporter text mocha",
-    "eslint": "eslint ."
+    "build": "rm -rf dist/ && deno-node-build --root . --out dist/ --entry lib/index.ts",
+    "test": "c8 --reporter lcov --reporter html --reporter text --all --src lib/ mocha test/**/*.ts",
+    "lint": "eslint ."
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@k13engineering/releasetool": "^0.0.5",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.0.3",
+    "c8": "^10.1.3",
+    "deno-node": "^0.0.12",
+    "eslint": "^9.39.2",
+    "mocha": "^11.7.5",
+    "tmp-promise": "^3.0.3",
+    "typescript-eslint": "^8.52.0"
   },
   "repository": {
     "type": "git",
@@ -27,15 +41,5 @@
   "bugs": {
     "url": "https://github.com/k13-engineering/node-ya-struct/issues"
   },
-  "homepage": "https://github.com/k13-engineering/node-ya-struct#readme",
-  "dependencies": {
-    "buffer2address": "^0.0.2"
-  },
-  "devDependencies": {
-    "c8": "^7.9.0",
-    "eslint": "^7.32.0",
-    "mocha": "^9.1.1",
-    "node-archibald": "^0.0.6",
-    "tmp-promise": "^3.0.3"
-  }
+  "homepage": "https://github.com/k13-engineering/node-ya-struct#readme"
 }

package/package.npm.json

@@ -0,0 +1,25 @@
+{
+  "name": "ya-struct",
+  "description": "Yet Another Node.js Structure API",
+  "main": "dist/lib/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k13-engineering/node-ya-struct.git"
+  },
+  "keywords": [
+    "structure",
+    "struct",
+    "abi",
+    "endian",
+    "alignment",
+    "c",
+    "c++",
+    "layout"
+  ],
+  "author": "Simon Kadisch",
+  "license": "LGPL 2.1",
+  "bugs": {
+    "url": "https://github.com/k13-engineering/node-ya-struct/issues"
+  },
+  "homepage": "https://github.com/k13-engineering/node-ya-struct#readme"
+}

package/samples/basic.ts

@@ -0,0 +1,40 @@
+import { define, types } from "../lib/index.ts";
+
+const def = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "a", definition: types.Int16 },
+      { name: "b", definition: types.UInt16 },
+      { name: "c", definition: types.UInt32 },
+    ]
+  }
+});
+
+const parser = def.parser({
+  abi: {
+    endianness: "little",
+    dataModel: "LP64",
+    compiler: "gcc",
+  }
+});
+
+const value: ReturnType<typeof parser.parse> = {
+  a: 0n,
+  b: 1n,
+  c: 2n,
+};
+
+console.log("value", value);
+
+const formatted = parser.format({
+  value
+});
+
+console.log("formatted", formatted);
+
+const reparsed = parser.parse({ data: formatted });
+
+console.log("reparsed", reparsed);