ya-struct 0.0.9 → 0.0.11

package/dist/lib/layout.js

@@ -42,12 +42,12 @@ import nodeUtil from "node:util";
 
 const pointerSizeInBitsByDataModel = ({ dataModel }/*: { dataModel: TAbi["dataModel"] }*/)/*: number*/ => {
   switch (dataModel) {
-    case "LP64":
-      return 64;
-    case "ILP32":
-      return 32;
-    default:
-      throw Error(`unsupported data model "${dataModel}" for pointer size determination`);
+  case "LP64":
+    return 64;
+  case "ILP32":
+    return 32;
+  default:
+    throw Error(`unsupported data model "${dataModel}" for pointer size determination`);
   }
 };
 
@@ -82,53 +82,53 @@ const layoutStruct = ({
 
     if (!definition.packed) {
       switch (normalizedField.type) {
-        case "integer":
-        case "float": {
-          const sizeInBits = normalizedField.sizeInBits;
-
-          if (abi.compiler === "gcc" && abi.dataModel === "ILP32" && sizeInBits === 64) {
-            // special handling for gcc 64-bit integers on ILP32 data model (alignment to 32 bits)
-            currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: 32 });
-          } else {
-            currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: sizeInBits });
-          }
-
-          break;
+      case "integer":
+      case "float": {
+        const sizeInBits = normalizedField.sizeInBits;
+
+        if (abi.compiler === "gcc" && abi.dataModel === "ILP32" && sizeInBits === 64) {
+          // special handling for gcc 64-bit integers on ILP32 data model (alignment to 32 bits)
+          currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: 32 });
+        } else {
+          currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: sizeInBits });
         }
-        case "array": {
 
-          // TODO: this is probably not sufficient for all cases
+        break;
+      }
+      case "array": {
 
-          // eslint-disable-next-line no-use-before-define
-          const { sizeInBits } = layout({ definition: normalizedField.elementType, abi, currentOffsetInBits: 0 });
+        // TODO: this is probably not sufficient for all cases
 
-          if (abi.compiler === "gcc" && abi.dataModel === "ILP32" && sizeInBits === 64) {
-            // special handling for gcc 64-bit integers on ILP32 data model (alignment to 32 bits)
-            currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: 32 });
-          } else {
-            currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: sizeInBits });
-          }
+        // eslint-disable-next-line no-use-before-define
+        const { sizeInBits } = layout({ definition: normalizedField.elementType, abi, currentOffsetInBits: 0 });
 
-          break;
+        if (abi.compiler === "gcc" && abi.dataModel === "ILP32" && sizeInBits === 64) {
+          // special handling for gcc 64-bit integers on ILP32 data model (alignment to 32 bits)
+          currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: 32 });
+        } else {
+          currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: sizeInBits });
         }
-        case "struct": {
 
-          if (currentOffsetInBits % 64 !== 0) {
-            throw Error("nested struct alignment handling not implemented yet");
-          }
+        break;
+      }
+      case "struct": {
 
-          break;
-        }
-        case "string": {
-          // no special alignment needed
-          break;
-        }
-        case "pointer": {
-          currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: pointerSizeInBits });
-          break;
+        if (currentOffsetInBits % 64 !== 0) {
+          throw Error("nested struct alignment handling not implemented yet");
         }
-        default:
-          throw Error(`unsupported field type for struct layout: ${nodeUtil.inspect(field.definition)}`);
+
+        break;
+      }
+      case "string": {
+        // no special alignment needed
+        break;
+      }
+      case "pointer": {
+        currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: pointerSizeInBits });
+        break;
+      }
+      default:
+        throw Error(`unsupported field type for struct layout: ${nodeUtil.inspect(field.definition)}`);
       }
     }
 

package/dist/lib/parser.d.ts

@@ -19,7 +19,12 @@ type FieldValue<T extends TFieldType> = T extends {
 } ? StructValue<F & readonly {
     name: string;
     definition: TFieldType;
-}[]> : never;
+}[]> : T extends {
+    type: "c-type";
+    cType: "float" | "double" | "long double";
+} ? number : T extends {
+    type: "c-type";
+} ? bigint : never;
 type StructValue<F extends readonly {
     name: string;
     definition: TFieldType;

package/dist/lib/parser.js

@@ -13,6 +13,8 @@ import { createStructParser } from "./types/struct.js";
   ? FieldValue<E & TFieldType>[] :
   T extends { type: "struct"; fields: infer F }
   ? StructValue<F & readonly { name: string; definition: TFieldType }[]> :
+  T extends { type: "c-type"; cType: "float" | "double" | "long double" } ? number :
+  T extends { type: "c-type" } ? bigint :
   never;*/
 
 /*type StructValue<
@@ -51,6 +53,7 @@ const define = /*<const T extends TFieldType>*/({ definition }/*: { definition:
     if (l.type === "struct") {
       valueParser = createStructParser({
         layoutedFields: l.fields,
+        structOffsetInBits: l.offsetInBits,
         endianness: abi.endianness
       }) /*as unknown*/ /*as TValueParser<TParsedValueOfDefinition<T>>*/;
     } else {

package/dist/lib/types/array.js

@@ -43,6 +43,7 @@ const createArrayParser = ({
     for (let i = 0; i < length; i += 1) {
       const fieldData = data.subarray(i * elementSizeInBytes, (i + 1) * elementSizeInBytes);
       const fieldValue = fieldParser.parse({ data: fieldData, offsetInBits: 0 });
+      // eslint-disable-next-line fp/no-mutating-methods -- performance
       result.push(fieldValue);
     }
 

package/dist/lib/types/string.js

@@ -42,6 +42,7 @@ const createStringParser = ({ length }/*: { length: number }*/)/*: TStringParser
     }
 
     target.set(encoded, 0);
+    // eslint-disable-next-line immutable/no-mutation -- performance
     target[encoded.length] = 0;
   };
 

package/dist/lib/types/struct.d.ts

@@ -2,10 +2,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 }: {
+declare const createStructParser: ({ layoutedFields, structOffsetInBits, endianness }: {
     layoutedFields: (TLayoutedField & {
         type: "struct";
     })["fields"];
+    structOffsetInBits: number;
     endianness: TEndianness;
 }) => TStructParser;
 export { createStructParser };

package/dist/lib/types/struct.js

@@ -9,11 +9,20 @@ import { createArrayParser } from "./array.js";
 
 /*type TStructParser = TValueParser<Record<string, unknown>>;*/
 
+const subData = ({ data, offsetInBits, sizeInBits }/*: { data: Uint8Array, offsetInBits: number, sizeInBits: number }*/) => {
+  return {
+    data: new Uint8Array(data.buffer, data.byteOffset + Math.floor(offsetInBits / 8), Math.ceil(sizeInBits / 8)),
+    offsetInBits: offsetInBits % 8
+  };
+};
+
 const createStructParser = ({
   layoutedFields,
+  structOffsetInBits,
   endianness
 }/*: {
   layoutedFields: (TLayoutedField & { type: "struct" })["fields"];
+  structOffsetInBits: number;
   endianness: TEndianness
 }*/)/*: TStructParser*/ => {
 
@@ -37,6 +46,7 @@ const createStructParser = ({
     if (field.definition.type === "struct") {
       return createStructParser({
         layoutedFields: field.definition.fields,
+        structOffsetInBits: field.definition.offsetInBits,
         endianness
       });
     }
@@ -70,19 +80,36 @@ const createStructParser = ({
     layoutedFields.forEach((field, idx) => {
       const fieldParser = fieldParsers[idx];
 
+      // field definition is absolute, subtracting struct offset gives bit offset inside struct
+      // adding data bit offset gives bit offset inside provided data
+      const offsetToProvidedDataInBits = field.definition.offsetInBits - structOffsetInBits + offsetInBits;
+
       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 });
+      const {
+        data: fieldData,
+        offsetInBits: fieldOffsetInBits
+      } = subData({
+        data,
+        offsetInBits: offsetToProvidedDataInBits,
+        sizeInBits: field.definition.sizeInBits
+      });
+
+      // eslint-disable-next-line immutable/no-mutation -- performance
+      result[field.name] = fieldParser.parse({ data: fieldData, offsetInBits: fieldOffsetInBits });
     });
 
     return result;
   };
 
   const format/*: TStructParser["format"]*/ = ({ value, target, offsetInBits }) => {
+    if (offsetInBits % 8 !== 0) {
+      throw Error("unaligned struct formatting not supported yet");
+    }
+
     layoutedFields.forEach((field, idx) => {
       const fieldValue = value[field.name];
       const fieldParser = fieldParsers[idx];
@@ -92,10 +119,17 @@ const createStructParser = ({
         throw Error("not implemented yet: unaligned field formatting");
       }
 
-      const fieldTarget = new Uint8Array(target.buffer, target.byteOffset + (field.definition.offsetInBits / 8));
+      const {
+        data: fieldTarget,
+        offsetInBits: fieldOffsetInBits
+      } = subData({
+        data: target,
+        offsetInBits: field.definition.offsetInBits - structOffsetInBits + offsetInBits,
+        sizeInBits: field.definition.sizeInBits
+      });
 
       try {
-        fieldParser.format({ value: fieldValue, target: fieldTarget, offsetInBits });
+        fieldParser.format({ value: fieldValue, target: fieldTarget, offsetInBits: fieldOffsetInBits });
       } catch (ex) {
         throw Error(`failed to format field "${field.name}"`, { cause: ex });
       }

package/package.json

@@ -1,26 +1,31 @@
 {
-  "version": "0.0.9",
+  "version": "0.0.11",
   "name": "ya-struct",
   "type": "module",
   "description": "Yet Another Node.js Structure API",
+  "files": [
+    "dist"
+  ],
   "main": "dist/lib/index.js",
   "scripts": {
     "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 ."
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "update-deps": "npm-check-updates -u"
   },
   "dependencies": {},
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "@k13engineering/eslint-rules": "^0.0.5",
     "@k13engineering/releasetool": "^0.0.5",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^25.0.3",
-    "c8": "^10.1.3",
+    "@types/node": "^25.6.0",
+    "c8": "^11.0.0",
     "deno-node": "^0.0.12",
-    "eslint": "^9.39.2",
     "mocha": "^11.7.5",
     "tmp-promise": "^3.0.3",
-    "typescript-eslint": "^8.52.0"
+    "typescript": "^6.0.3"
   },
   "repository": {
     "type": "git",

package/.editorconfig

@@ -1,8 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true

package/.github/workflows/ci.yml

@@ -1,23 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest
-    name: Continous integration tests
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'
-      - name: Install libc6-dev-i386
-        run: sudo apt-get update && sudo apt-get install -y libc6-dev-i386
-      - name: Install dependencies
-        run: npm ci
-      - name: Build
-        run: npm run build
-      - name: Run tests
-        run: npm run test
-      - name: Verify code with linter
-        run: npm run lint

package/.github/workflows/npm-publish.yml

@@ -1,28 +0,0 @@
-name: Publish Package to npmjs
-on:
-  push:
-    tags:
-      - '*'
-
-permissions:
-  id-token: write  # Required for OIDC
-  contents: read
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm ci
-      - run: npm run build
-      - run: node node_modules/.bin/releasetool merge --local-package-json package.json --npm-package-json package.npm.json --output package.json
-      - run: node node_modules/.bin/releasetool patch-version --package-json package.json --package-version ${{ github.ref_name }}
-      - run: npm publish

package/eslint.config.js

@@ -1,127 +0,0 @@
-/* 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

@@ -1,70 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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
-};