ya-struct 0.0.4 → 0.0.6

package/dist/lib/types/integer.js

@@ -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/dist/lib/types/pointer.d.ts

@@ -0,0 +1,8 @@
+import type { TEndianness } from "../common.js";
+import type { TValueParser } from "./value.js";
+type TPointerParser = TValueParser<bigint>;
+declare const createPointerParser: ({ sizeInBits, endianness }: {
+    sizeInBits: number;
+    endianness: TEndianness;
+}) => TPointerParser;
+export { createPointerParser };

package/dist/lib/types/pointer.js

@@ -0,0 +1,27 @@
+/*import type { TEndianness } from "../common.ts";*/
+import { createIntegerParser } from "./integer.js";
+/*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/dist/lib/types/string.d.ts

@@ -0,0 +1,6 @@
+import type { TValueParser } from "./value.js";
+type TStringParser = TValueParser<string>;
+declare const createStringParser: ({ length }: {
+    length: number;
+}) => TStringParser;
+export { createStringParser };

package/dist/lib/types/string.js

@@ -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/dist/lib/types/struct.d.ts

@@ -0,0 +1,11 @@
+import type { TEndianness } from "../common.js";
+import type { TLayoutedField } from "../layout.js";
+import type { TValueParser } from "./value.js";
+type TStructParser = TValueParser<Record<string, unknown>>;
+declare const createStructParser: ({ layoutedFields, endianness }: {
+    layoutedFields: (TLayoutedField & {
+        type: "struct";
+    })["fields"];
+    endianness: TEndianness;
+}) => TStructParser;
+export { createStructParser };

package/dist/lib/types/struct.js

@@ -0,0 +1,113 @@
+/*import type { TEndianness } from "../common.ts";*/
+/*import type { TLayoutedField } from "../layout.ts";*/
+import { createIntegerParser } from "./integer.js";
+import { createPointerParser } from "./pointer.js";
+import { createStringParser } from "./string.js";
+import { createArrayParser } from "./array.js";
+/*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/dist/lib/types/value.d.ts

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

package/dist/lib/types/value.js

@@ -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/eslint.config.js

@@ -0,0 +1,127 @@
+/* c8 ignore start */
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  {
+    ignores: [
+      "dist/**/*"
+    ]
+  },
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    rules: {
+      "global-require": "off",
+      "quote-props": ["warn", "consistent-as-needed"],
+
+      "quotes": ["error", "double", {
+        allowTemplateLiterals: true,
+      }],
+
+      "no-plusplus": "error",
+      "no-nested-ternary": "error",
+      "no-multiple-empty-lines": "error",
+      "no-inline-comments": "error",
+      "no-lonely-if": "error",
+      "no-array-constructor": "error",
+      "no-delete-var": "error",
+      "no-param-reassign": "error",
+      "no-return-assign": "error",
+      "no-import-assign": "error",
+      "no-multi-assign": "error",
+      "keyword-spacing": "error",
+
+      "max-len": ["warn", {
+        code: 140,
+      }],
+
+      "max-params": ["error", 4],
+      "max-statements": ["error", 15],
+      "no-loss-of-precision": "error",
+      "no-unreachable-loop": "error",
+      "require-atomic-updates": "error",
+      "complexity": ["error", 4],
+
+      "max-statements-per-line": ["error", {
+        max: 1,
+      }],
+
+      "no-tabs": "error",
+      "no-underscore-dangle": "error",
+      "no-negated-condition": "error",
+      "no-use-before-define": "error",
+
+      "no-shadow": "off",
+      "@typescript-eslint/no-shadow": "error",
+
+      "no-labels": "error",
+      "no-throw-literal": "error",
+      "default-case": "error",
+      "default-case-last": "error",
+      "no-caller": "error",
+      "no-eval": "error",
+      "no-implied-eval": "error",
+      "no-new": "error",
+      "no-new-func": "error",
+      "no-new-object": "error",
+      "no-new-wrappers": "error",
+      "no-useless-concat": "error",
+
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": ["error", {
+        ignoreRestSiblings: true,
+      }],
+
+      "array-bracket-newline": ["error", "consistent"],
+      "func-names": ["error", "never"],
+
+      "func-style": ["error", "expression", {
+        allowArrowFunctions: true,
+      }],
+
+      "max-depth": ["error", 4],
+      "arrow-parens": "error",
+      "no-confusing-arrow": "error",
+      "prefer-const": "error",
+      "rest-spread-spacing": ["error", "never"],
+      "template-curly-spacing": ["error", "never"],
+      "prefer-rest-params": "error",
+      "prefer-spread": "error",
+      "prefer-template": "error",
+      "object-shorthand": ["error", "properties"],
+      "no-var": "error",
+      "no-useless-computed-key": "error",
+      "array-callback-return": "error",
+      "consistent-return": "error",
+      "dot-notation": "error",
+      "eqeqeq": "error",
+      "no-eq-null": "error",
+      "no-implicit-coercion": "error",
+      "no-multi-spaces": "error",
+      "no-proto": "error",
+      "yoda": "error",
+      "indent": ["error", 2, { SwitchCase: 1 }],
+      "object-curly-spacing": ["error", "always"],
+
+      "object-curly-newline": ["error", {
+        consistent: true,
+        multiline: true,
+      }],
+
+      "space-before-blocks": "error",
+      "space-before-function-paren": ["error", "always"],
+      "spaced-comment": "error",
+      "no-whitespace-before-property": "error",
+
+      "brace-style": ["error", "1tbs", {
+        allowSingleLine: false,
+      }],
+
+      "eol-last": ["error", "always"],
+      "func-call-spacing": ["error", "never"],
+      "semi": ["error", "always"],
+    }
+  }
+);
+/* c8 ignore stop */

package/lib/bit-buffer.ts

@@ -0,0 +1,70 @@
+type TBitBuffer = {
+  sizeInBits: number;
+  slice: (args: { startOffsetInBits: number, endOffsetInBits: number }) => TBitBuffer;
+  readBits: (args: { offsetInBits: number, lengthInBits: number }) => { data: Uint8Array, offsetInBits: number };
+}
+
+const bitBufferFromUint8Array = ({
+  data,
+  offsetInBits: dataOffsetInBits,
+  sizeInBits
+}: {
+  data: Uint8Array,
+  offsetInBits: number,
+  sizeInBits: number
+}): TBitBuffer => {
+
+  const slice: TBitBuffer["slice"] = ({ startOffsetInBits, endOffsetInBits }) => {
+    const totalStartOffsetInBits = dataOffsetInBits + startOffsetInBits;
+    const totalEndOffsetInBits = dataOffsetInBits + endOffsetInBits;
+
+    const byteStartOffset = (totalStartOffsetInBits) / 8;
+    const byteEndOffset = (totalEndOffsetInBits) / 8;
+
+    const newData = data.slice(byteStartOffset, byteEndOffset);
+    const newOffsetInBits = totalStartOffsetInBits % 8;
+
+    return bitBufferFromUint8Array({
+      data: newData,
+      offsetInBits: newOffsetInBits,
+      sizeInBits: endOffsetInBits - startOffsetInBits
+    });
+  };
+
+  const readBits: TBitBuffer["readBits"] = ({ offsetInBits: readOffsetInBits, lengthInBits }) => {
+    const totalOffsetInBits = dataOffsetInBits + readOffsetInBits;
+    const totalEndOffsetInBits = totalOffsetInBits + lengthInBits;
+
+    const byteOffset = (totalOffsetInBits) / 8;
+    const byteEndOffset = (totalEndOffsetInBits) / 8;
+
+    const bitData = data.slice(byteOffset, byteEndOffset);
+    const bitOffset = totalOffsetInBits % 8;
+
+    return {
+      offsetInBits: bitOffset,
+      data: bitData
+    };
+  };
+
+  return {
+    sizeInBits,
+    readBits,
+    slice,
+  };
+};
+
+const createBitBuffer = ({ sizeInBits, offsetInBits }: { sizeInBits: number, offsetInBits: number }) => {
+  const byteLength = Math.ceil(sizeInBits / 8);
+  const buffer = new Uint8Array(byteLength);
+  return bitBufferFromUint8Array({ data: buffer, offsetInBits, sizeInBits });
+};
+
+export {
+  createBitBuffer,
+  bitBufferFromUint8Array
+};
+
+export type {
+  TBitBuffer
+};

package/lib/common.ts

@@ -0,0 +1,30 @@
+type TDataModel = "LP64" | "ILP32";
+type TCompiler = "gcc";
+type TEndianness = "little" | "big";
+
+type TAbi = {
+  endianness: TEndianness;
+  compiler: TCompiler;
+  dataModel: TDataModel;
+};
+
+const align = ({ offset, alignment }: { offset: number; alignment: number }): number => {
+  const remainder = offset % alignment;
+  if (remainder === 0) {
+    return offset;
+  }
+
+  return offset + (alignment - remainder);
+};
+
+export type {
+  TDataModel,
+  TCompiler,
+  TEndianness,
+
+  TAbi
+};
+
+export {
+  align
+};

package/lib/index.ts

@@ -0,0 +1,21 @@
+import { define } from "./parser.ts";
+import { types } from "./types/index.ts";
+
+import type {
+  TAbi,
+  TCompiler,
+  TDataModel,
+  TEndianness,
+} from "./common.ts";
+
+export {
+  define,
+  types
+};
+
+export type {
+  TAbi,
+  TEndianness,
+  TCompiler,
+  TDataModel
+};