ya-struct 0.0.10 → 0.0.12

package/dist/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { define } from "./parser.js";
 import { types } from "./types/index.js";
+import { compileAndCompare } from "./tests/compile-and-compare.vibe.js";
 import type { TAbi, TCompiler, TDataModel, TEndianness } from "./common.js";
-export { define, types };
+export { define, types, compileAndCompare };
 export type { TAbi, TEndianness, TCompiler, TDataModel };

package/dist/lib/index.js

@@ -1,5 +1,6 @@
 import { define } from "./parser.js";
 import { types } from "./types/index.js";
+import { compileAndCompare } from "./tests/compile-and-compare.vibe.js";
 
 /*import type {
   TAbi,
@@ -10,7 +11,8 @@ import { types } from "./types/index.js";
 
 export {
   define,
-  types
+  types,
+  compileAndCompare
 };
 
 /*export type {

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;
@@ -49,3 +54,4 @@ declare const define: <const T extends TFieldType>({ definition }: {
     }) => TParser<T>;
 };
 export { define };
+export type { TParser, };

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<
@@ -86,3 +88,7 @@ const define = /*<const T extends TFieldType>*/({ definition }/*: { definition:
 export {
   define
 };
+
+/*export type {
+  TParser,
+};*/

package/dist/lib/tests/compile-and-compare.vibe.d.ts

@@ -0,0 +1,30 @@
+import type { TAbi } from "../common.js";
+import type { TFieldType } from "../types/index.js";
+type TLayoutError = {
+    type: "size-mismatch";
+    fieldPath: string;
+    expectedSizeInBits: number;
+    actualSizeInBits: number;
+} | {
+    type: "offset-mismatch";
+    fieldPath: string;
+    expectedOffsetInBits: number;
+    actualOffsetInBits: number;
+};
+type TCompileAndCompareResult = {
+    layoutErrors: TLayoutError[];
+};
+declare const compileAndCompare: ({ structDefinition, abi, globalCode, cStructName, compileAndRun }: {
+    structDefinition: Extract<TFieldType, {
+        type: "struct";
+    }>;
+    abi: TAbi;
+    globalCode: string;
+    cStructName: string;
+    compileAndRun: ({ sourceCode }: {
+        sourceCode: string;
+    }) => Promise<{
+        output: string;
+    }>;
+}) => Promise<TCompileAndCompareResult>;
+export { compileAndCompare };

package/dist/lib/tests/compile-and-compare.vibe.js

@@ -0,0 +1,221 @@
+/*import type { TAbi } from "../common.ts";*/
+/*import type { TLayoutedField } from "../layout.ts";*/
+import { define } from "../parser.js";
+/*import type { TFieldType } from "../types/index.ts";*/
+
+/*type TLayoutError = {
+  type: "size-mismatch",
+  fieldPath: string;
+  expectedSizeInBits: number;
+  actualSizeInBits: number;
+} | {
+  type: "offset-mismatch",
+  fieldPath: string;
+  expectedOffsetInBits: number;
+  actualOffsetInBits: number;
+};*/
+
+/*type TCompileAndCompareResult = {
+  layoutErrors: TLayoutError[];
+};*/
+
+/*type TFlatField = {
+  fieldPath: string;
+  offsetInBits: number;
+  sizeInBits: number;
+  isStruct: boolean;
+};*/
+
+/*type TStructLayoutedFields =
+  (TLayoutedField & { type: "struct" })["fields"];*/
+
+const flattenLayout = ({
+  fields,
+  parentPath
+}/*: {
+  fields: TStructLayoutedFields;
+  parentPath: string;
+}*/)/*: TFlatField[]*/ => {
+  return fields.flatMap((field) => {
+    const fieldPath = parentPath
+      ? `${parentPath}.${field.name}`
+      : field.name;
+
+    const isStruct = field.definition.type === "struct";
+
+    const entry/*: TFlatField*/ = {
+      fieldPath,
+      offsetInBits: field.definition.offsetInBits,
+      sizeInBits: field.definition.sizeInBits,
+      isStruct,
+    };
+
+    if (isStruct) {
+      return [
+        entry,
+        ...flattenLayout({
+          fields: field.definition.fields,
+          parentPath: fieldPath,
+        }),
+      ];
+    }
+
+    return [entry];
+  });
+};
+
+const generateSourceCode = ({
+  globalCode,
+  cStructName,
+  flatFields,
+}/*: {
+  globalCode: string;
+  cStructName: string;
+  flatFields: TFlatField[];
+}*/) => {
+
+  const printStatements = flatFields.map((f, idx) => {
+    if (f.isStruct) {
+      const offsetExpr =
+        `offsetof(struct ${cStructName}, ${f.fieldPath}) * CHAR_BIT`;
+      const sizeExpr =
+        `sizeof(((struct ${cStructName}*)0)->${f.fieldPath}) * CHAR_BIT`;
+
+      return `  printf("%zu %zu\\n", `
+        + `(size_t)(${offsetExpr}), (size_t)(${sizeExpr}));`;
+    }
+
+    // Use memory scanning to detect actual bit offset and size.
+    // This works for both regular fields and bitfields.
+    return `  {
+    struct ${cStructName} __s${idx};
+    memset(&__s${idx}, 0, sizeof(__s${idx}));
+    memset(&__s${idx}.${f.fieldPath}, 0xFF, sizeof(__s${idx}.${f.fieldPath}));
+    unsigned char *__p${idx} = (unsigned char *)&__s${idx};
+    size_t __off${idx} = 0, __sz${idx} = 0;
+    int __found${idx} = 0;
+    for (size_t __i = 0; __i < sizeof(struct ${cStructName}) * CHAR_BIT; __i++) {
+      if (__p${idx}[__i / CHAR_BIT] & (1u << (__i % CHAR_BIT))) {
+        if (!__found${idx}) { __off${idx} = __i; __found${idx} = 1; }
+        __sz${idx}++;
+      }
+    }
+    printf("%zu %zu\\n", __off${idx}, __sz${idx});
+  }`;
+  }).join("\n");
+
+  return `#include <stdio.h>
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+${globalCode}
+
+int main(void) {
+${printStatements}
+  return 0;
+}
+`;
+};
+
+const parseCOutput = ({
+  output,
+}/*: {
+  output: string;
+}*/)/*: { offset: number; size: number }[]*/ => {
+  return output.trim().split("\n").map((line) => {
+    const parts = line.trim().split(" ");
+    return {
+      offset: parseInt(parts[0], 10),
+      size: parseInt(parts[1], 10),
+    };
+  });
+};
+
+const compareLayouts = ({
+  flatFields,
+  cFields,
+}/*: {
+  flatFields: TFlatField[];
+  cFields: { offset: number; size: number }[];
+}*/)/*: TLayoutError[]*/ => {
+  return flatFields.flatMap((field, idx) => {
+    const cField = cFields[idx];
+    if (!cField) {
+      return [];
+    }
+
+    const sizeMismatch/*: TLayoutError[]*/ =
+      cField.size === field.sizeInBits
+        ? []
+        : [{
+          type: "size-mismatch" /*as const*/,
+          fieldPath: field.fieldPath,
+          expectedSizeInBits: cField.size,
+          actualSizeInBits: field.sizeInBits,
+        }];
+
+    const offsetMismatch/*: TLayoutError[]*/ =
+      cField.offset === field.offsetInBits
+        ? []
+        : [{
+          type: "offset-mismatch" /*as const*/,
+          fieldPath: field.fieldPath,
+          expectedOffsetInBits: cField.offset,
+          actualOffsetInBits: field.offsetInBits,
+        }];
+
+    return [...sizeMismatch, ...offsetMismatch];
+  });
+};
+
+const compileAndCompare = async ({
+  structDefinition,
+  abi,
+
+  globalCode,
+  cStructName,
+
+  compileAndRun
+}/*: {
+  structDefinition: Extract<TFieldType, { type: "struct" }>;
+  abi: TAbi;
+
+  globalCode: string;
+  cStructName: string;
+
+  compileAndRun: ({ sourceCode }: { sourceCode: string }) => Promise<{
+    output: string;
+  }>;
+}*/)/*: Promise<TCompileAndCompareResult>*/ => {
+
+  const def = define({ definition: structDefinition });
+  const parser = def.parser({ abi });
+  const layoutResult = parser.layout;
+
+  if (layoutResult.type !== "struct") {
+    throw Error("expected struct layout");
+  }
+
+  const flatFields = flattenLayout({
+    fields: layoutResult.fields,
+    parentPath: "",
+  });
+
+  const sourceCode = generateSourceCode({
+    globalCode,
+    cStructName,
+    flatFields,
+  });
+
+  const { output } = await compileAndRun({ sourceCode });
+
+  const cFields = parseCOutput({ output });
+
+  const layoutErrors = compareLayouts({ flatFields, cFields });
+
+  return { layoutErrors };
+};
+
+export {
+  compileAndCompare
+};

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.js

@@ -98,6 +98,7 @@ const createStructParser = ({
         sizeInBits: field.definition.sizeInBits
       });
 
+      // eslint-disable-next-line immutable/no-mutation -- performance
       result[field.name] = fieldParser.parse({ data: fieldData, offsetInBits: fieldOffsetInBits });
     });
 

package/package.json

@@ -1,26 +1,31 @@
 {
-  "version": "0.0.10",
+  "version": "0.0.12",
   "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 */