ya-struct 0.0.10 → 0.0.11

package/lib/types/index.ts

@@ -1,122 +0,0 @@
-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 }) => {
-  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

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

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

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

@@ -1,146 +0,0 @@
-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 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 => {
-
-  // 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,
-        structOffsetInBits: field.definition.offsetInBits,
-        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];
-
-      // 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 {
-        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];
-
-      const offsetInBitsInByte = field.definition.offsetInBits % 8;
-      if (offsetInBitsInByte !== 0) {
-        throw Error("not implemented yet: unaligned field formatting");
-      }
-
-      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: fieldOffsetInBits });
-      } catch (ex) {
-        throw Error(`failed to format field "${field.name}"`, { cause: ex });
-      }
-    });
-  };
-
-  return {
-    parse,
-    format
-  };
-};
-
-export {
-  createStructParser
-};

package/lib/types/value.ts

@@ -1,8 +0,0 @@
-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.npm.json

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,40 +0,0 @@
-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);