ya-struct 0.0.8 → 0.0.10

package/dist/lib/layout.js

@@ -111,6 +111,14 @@ const layoutStruct = ({
 
           break;
         }
+        case "struct": {
+
+          if (currentOffsetInBits % 64 !== 0) {
+            throw Error("nested struct alignment handling not implemented yet");
+          }
+
+          break;
+        }
         case "string": {
           // no special alignment needed
           break;

package/dist/lib/parser.js

@@ -51,6 +51,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/string.js

@@ -37,7 +37,7 @@ const createStringParser = ({ length }/*: { length: number }*/)/*: TStringParser
 
     const encoded = encoder.encode(value);
 
-    if (encoded.length + 1 >= length) {
+    if (encoded.length + 1 > length) {
       throw Error("string too long to fit in target");
     }
 

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,35 @@ 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
+      });
+
+      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 +118,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/lib/layout.ts

@@ -111,6 +111,14 @@ const layoutStruct = ({
 
           break;
         }
+        case "struct": {
+
+          if (currentOffsetInBits % 64 !== 0) {
+            throw Error("nested struct alignment handling not implemented yet");
+          }
+
+          break;
+        }
         case "string": {
           // no special alignment needed
           break;

package/lib/parser.ts

@@ -51,6 +51,7 @@ const define = <const T extends TFieldType>({ definition }: { definition: T }) =
     if (l.type === "struct") {
       valueParser = createStructParser({
         layoutedFields: l.fields,
+        structOffsetInBits: l.offsetInBits,
         endianness: abi.endianness
       }) as unknown as TValueParser<TParsedValueOfDefinition<T>>;
     } else {

package/lib/types/string.ts

@@ -37,7 +37,7 @@ const createStringParser = ({ length }: { length: number }): TStringParser => {
 
     const encoded = encoder.encode(value);
 
-    if (encoded.length + 1 >= length) {
+    if (encoded.length + 1 > length) {
       throw Error("string too long to fit in target");
     }
 

package/lib/types/struct.ts

@@ -9,11 +9,20 @@ import type { TFieldType } from "./index.ts";
 
 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,35 @@ 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
+      });
+
+      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 +118,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,5 +1,5 @@
 {
-  "version": "0.0.8",
+  "version": "0.0.10",
   "name": "ya-struct",
   "type": "module",
   "description": "Yet Another Node.js Structure API",

package/test/nested-structs.ts

@@ -0,0 +1,78 @@
+import nodeAssert from "node:assert";
+import { define } from "../lib/parser.ts";
+import { types } from "../lib/types/index.ts";
+
+const abi = {
+  compiler: "gcc",
+  dataModel: "LP64",
+  endianness: "little",
+} as const;
+
+const innerStructDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "a", definition: types.UInt64 },
+    { name: "b", definition: types.UInt32 },
+    { name: "c", definition: types.UInt32 },
+  ],
+} as const;
+
+const outerStructDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "x", definition: types.UInt64 },
+    { name: "inner", definition: innerStructDefinition },
+  ],
+} as const;
+
+const expectedEncoded = () => {
+  const data = new Uint8Array(24);
+  const view = new DataView(data.buffer);
+
+  view.setBigUint64(0, 1n, true);
+  view.setBigUint64(8, 2n, true);
+  view.setUint32(16, 3, true);
+  view.setUint32(20, 4, true);
+
+  return data;
+};
+
+describe("nested-structs", () => {
+  it("should format nested structs", () => {
+    const parser = define({ definition: outerStructDefinition }).parser({ abi });
+
+    const encoded = parser.format({
+      value: {
+        x: 1n,
+        inner: {
+          a: 2n,
+          b: 3n,
+          c: 4n,
+        },
+      },
+    });
+
+    nodeAssert.deepStrictEqual(encoded, expectedEncoded());
+  });
+
+  it("should parse nested structs", () => {
+    const parser = define({ definition: outerStructDefinition }).parser({ abi });
+
+    const parsed = parser.parse({
+      data: expectedEncoded(),
+    });
+
+    nodeAssert.deepStrictEqual(parsed, {
+      x: 1n,
+      inner: {
+        a: 2n,
+        b: 3n,
+        c: 4n,
+      },
+    });
+  });
+});

package/tsconfig.json

@@ -5,6 +5,7 @@
     "moduleResolution": "NodeNext",
     "noEmit": true,
     "esModuleInterop": true,
-    "strict": true
+    "strict": true,
+    "verbatimModuleSyntax": true
   }
 }