Upgraded dependencies, added initial tests, updated how arrays are build.

Author: Rechdan

.eslintignore

@@ -1,16 +1,8 @@
 {
- "env": {
- "browser": true,
- "es2021": true,
- "node": true
- },
+ "env": { "browser": true, "es2021": true, "node": true },
  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
  "parser": "@typescript-eslint/parser",
- "parserOptions": {
- "ecmaFeatures": { "jsx": true },
- "ecmaVersion": "latest",
- "sourceType": "module"
- },
+ "parserOptions": { "ecmaFeatures": { "jsx": true }, "ecmaVersion": "latest", "sourceType": "module" },
  "plugins": ["@typescript-eslint"],
  "rules": {
  "@typescript-eslint/explicit-module-boundary-types": "off",

.eslintrc.json

@@ -0,0 +1 @@
+v18.13.0

.nvmrc

@@ -0,0 +1,3 @@
+{
+ "typescript.tsserver.experimental.enableProjectDiagnostics": true
+}

.vscode/settings.json

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+ preset: "ts-jest",
+ testEnvironment: "node",
+ moduleNameMapper: {
+ "^_/(.*)$": "<rootDir>/src/$1",
+ },
+};

jest.config.js

@@ -1,6 +1,6 @@
 {
  "name": "typed-buffer-struct",
- "version": "0.0.8",
+ "version": "0.1.0",
  "description": "This is a package which helps the user to create a Struct with automatic Buffer creation.",
  "author": {
  "name": "Nelson Faiçal Rechdan",
@@ -13,18 +13,22 @@
  "main": "dist/index.js",
  "license": "MIT",
  "scripts": {
- "upgrade": "clear && ncu -t greatest -f \"/eslint/\" -u && ncu -u && yarn --check-files",
- "build": "ttsc && rm -rf \"./dist\" && mv \"./temp\" \"./dist\"",
- "pub:alpha": "clear && yarn run build && npm publish --tag alpha --access public"
+ "upgrade": "ncu -u && yarn --check-files",
+ "test": "jest",
+ "test:watch": "jest --watch",
+ "build": "ttsc && rm -rf \"./dist\" && mv \"./temp\" \"./dist\""
  },
  "devDependencies": {
- "@types/node": "16.11.9",
- "@typescript-eslint/eslint-plugin": "5.4.1-alpha.18",
- "@typescript-eslint/parser": "5.4.1-alpha.18",
- "eslint": "8.3.0",
- "ttypescript": "1.5.12",
- "typescript": "4.5.2",
- "typescript-transform-paths": "3.3.1"
+ "@types/jest": "29.2.5",
+ "@types/node": "18.11.18",
+ "@typescript-eslint/eslint-plugin": "5.48.2",
+ "@typescript-eslint/parser": "5.48.2",
+ "eslint": "8.32.0",
+ "jest": "29.3.1",
+ "ts-jest": "29.0.5",
+ "ttypescript": "1.5.15",
+ "typescript": "4.9.4",
+ "typescript-transform-paths": "3.4.6"
  },
  "files": [
  "package.json",

package.json

@@ -51,7 +51,7 @@ const structString: StructString = (builder, size, name, strLength) => {
 
 const structStruct: StructStruct = (builder, size, name, struct) => {
  builder.push((obj, buffer) => {
- const structObj = struct(buffer.slice(size, size + struct.size));
+ const structObj = struct(buffer.subarray(size, size + struct.size));
  delete (structObj as { buffer: unknown }).buffer;
  Object.defineProperty(obj, name, {
  get: () => structObj,
@@ -97,15 +97,15 @@ const arrayBigNumberFunction: BuildArrayResponseBigNumberFunction = (arrLength,
  };
 };
 
-const buildArray: BuildArray = () => ({
+const buildArray: BuildArray = (arrLength) => ({
  // arrays
- array: (arrLength, build) => {
- const { size: buildSize, builder: buildBuilder } = build(buildArray());
+ array: (arrLength2, build) => {
+ const { size: buildSize, builder: buildBuilder } = build(buildArray(arrLength2));
  return {
  size: buildSize * arrLength,
  builder: (arr, buffer) => {
  for (let i = 0; i < arrLength; i++) {
- const arr2 = buildBuilder([], buffer.slice(buildSize * i, buildSize * (i + 1)));
+ const arr2 = buildBuilder([], buffer.subarray(buildSize * i, buildSize * (i + 1)));
  Object.defineProperty(arr, i, {
  get: () => arr2,
  enumerable: true,
@@ -116,17 +116,17 @@ const buildArray: BuildArray = () => ({
  };
  },
  // numbers
- sbyte: (arrLength) => arrayNumberFunction(arrLength, "sbyte"),
- byte: (arrLength) => arrayNumberFunction(arrLength, "byte"),
- short: (arrLength) => arrayNumberFunction(arrLength, "short"),
- ushort: (arrLength) => arrayNumberFunction(arrLength, "ushort"),
- int: (arrLength) => arrayNumberFunction(arrLength, "int"),
- uint: (arrLength) => arrayNumberFunction(arrLength, "uint"),
+ sbyte: () => arrayNumberFunction(arrLength, "sbyte"),
+ byte: () => arrayNumberFunction(arrLength, "byte"),
+ short: () => arrayNumberFunction(arrLength, "short"),
+ ushort: () => arrayNumberFunction(arrLength, "ushort"),
+ int: () => arrayNumberFunction(arrLength, "int"),
+ uint: () => arrayNumberFunction(arrLength, "uint"),
  // big numbers
- long: (arrLength) => arrayBigNumberFunction(arrLength, "long"),
- ulong: (arrLength) => arrayBigNumberFunction(arrLength, "ulong"),
+ long: () => arrayBigNumberFunction(arrLength, "long"),
+ ulong: () => arrayBigNumberFunction(arrLength, "ulong"),
  // extras
- string: (arrLength, stringLength) => ({
+ string: (stringLength) => ({
  size: arrLength * stringLength,
  builder: (arr, buffer) => {
  for (let i = 0; i < arrLength; i++) {
@@ -139,11 +139,11 @@ const buildArray: BuildArray = () => ({
  return arr;
  },
  }),
- struct: (arrLength, struct) => ({
+ struct: (struct) => ({
  size: arrLength * struct.size,
  builder: (arr, buffer) => {
  for (let i = 0; i < arrLength; i++) {
- const structObj = struct(buffer.slice(i * struct.size, (i + 1) * struct.size));
+ const structObj = struct(buffer.subarray(i * struct.size, (i + 1) * struct.size));
  delete (structObj as { buffer: unknown }).buffer;
  Object.defineProperty(arr, i, {
  get: () => structObj,
@@ -155,10 +155,10 @@ const buildArray: BuildArray = () => ({
  }),
 });
 
-const structArray: StructArray = (builder, size, name, build) => {
- const { size: buildSize, builder: buildBuilder } = build(buildArray());
+const structArray: StructArray = (builder, size, name, arrLength, build) => {
+ const { size: buildSize, builder: buildBuilder } = build(buildArray(arrLength));
  builder.push((obj, buffer) => {
- const arr = buildBuilder([], buffer.slice(size, buildSize + size));
+ const arr = buildBuilder([], buffer.subarray(size, buildSize + size));
  Object.defineProperty(obj, name, {
  get: () => arr,
  enumerable: true,
@@ -183,7 +183,7 @@ const createStruct: CreateStruct<{}> = (builder = [], size = 0) => ({
  // extras
  string: (name, length) => structString(builder, size, name, length),
  struct: (name, struct) => structStruct(builder, size, name, struct),
- array: (name, build) => structArray(builder, size, name, build),
+ array: (name, arrLength, build) => structArray(builder, size, name, arrLength, build),
  offset: (length) => createStruct(builder, size + length),
  // build
  build: () => {

src/struct/index.ts

@@ -41,24 +41,30 @@ export type BuildArrayResponseBigNumberFunction = (length: number, type: BigNumb
 
 export type BuildArrayResponse = {
  // numbers
- sbyte: (arrLength: number) => BuildArrayResponseNumberResult;
- byte: (arrLength: number) => BuildArrayResponseNumberResult;
- short: (arrLength: number) => BuildArrayResponseNumberResult;
- ushort: (arrLength: number) => BuildArrayResponseNumberResult;
- int: (arrLength: number) => BuildArrayResponseNumberResult;
- uint: (arrLength: number) => BuildArrayResponseNumberResult;
+ sbyte: () => BuildArrayResponseNumberResult;
+ byte: () => BuildArrayResponseNumberResult;
+ short: () => BuildArrayResponseNumberResult;
+ ushort: () => BuildArrayResponseNumberResult;
+ int: () => BuildArrayResponseNumberResult;
+ uint: () => BuildArrayResponseNumberResult;
  // big number
- long: (arrLength: number) => BuildArrayResponseBigNumberResult;
- ulong: (arrLength: number) => BuildArrayResponseBigNumberResult;
+ long: () => BuildArrayResponseBigNumberResult;
+ ulong: () => BuildArrayResponseBigNumberResult;
  // extra
  array: <T>(arrLength: number, build: ArrayBuilder<T>) => ArrayBuilderResponse<T[]>;
- string: (arrLength: number, stringLength: number) => ArrayBuilderResponse<string[]>;
- struct: <T>(arrLength: number, struct: BuildStructResult<T>) => ArrayBuilderResponse<T[]>;
+ string: (stringLength: number) => ArrayBuilderResponse<string[]>;
+ struct: <T>(struct: BuildStructResult<T>) => ArrayBuilderResponse<T[]>;
 };
 
-export type BuildArray = () => BuildArrayResponse;
+export type BuildArray = (length: number) => BuildArrayResponse;
 
-export type StructArray = <T, T2, N extends string>(builder: Builder[], size: number, name: N, build: ArrayBuilder<T2>) => CreateStructResultOf<T, T2, N>;
+export type StructArray = <T, T2, N extends string>(
+ builder: Builder[],
+ size: number,
+ name: N,
+ arrLength: number,
+ build: ArrayBuilder<T2>
+) => CreateStructResultOf<T, T2, N>;
 
 // STRUCT
 
@@ -83,7 +89,7 @@ export type CreateStructResult<T> = {
  // extras
  string: <N extends string>(name: N, length: number) => CreateStructResultOf<T, string, N>;
  struct: <T2, N extends string>(name: N, struct: BuildStructResult<T2>) => CreateStructResultOf<T, T2, N>;
- array: <T2, N extends string>(name: N, build: ArrayBuilder<T2[]>) => CreateStructResultOf<T, T2[], N>;
+ array: <T2, N extends string>(name: N, arrLength: number, build: ArrayBuilder<T2[]>) => CreateStructResultOf<T, T2[], N>;
  offset: (length: number) => CreateStructResult<T>;
  // build
  build: () => BuildStructResult<{ [K in keyof T]: T[K] }>;

src/struct/types.ts

@@ -0,0 +1,136 @@
+import newStruct from "_/struct";
+
+const basicStruct = newStruct()
+ /* 0 to 15 = 16 */ .string("name", 16)
+ /* 16 = 1 */ .sbyte("sbyte")
+ /* 17 = 1 */ .byte("byte")
+ /* 18 to 19 = 2 */ .short("short")
+ /* 20 to 21 = 2 */ .ushort("ushort")
+ /* 22 to 25 = 4 */ .int("int")
+ /* 26 to 29 = 4 */ .uint("uint")
+ /* 30 to 37 = 8 */ .long("long")
+ /* 38 to 45 = 8 */ .ulong("ulong")
+ .build();
+
+describe("basic struct", () => {
+ test("buffer size", () => {
+ const structToTest = basicStruct();
+ expect(basicStruct.size).toBe(46);
+ expect(structToTest.buffer.byteLength).toBe(46);
+ });
+
+ test("is buffer empty", () => {
+ const structToTest = basicStruct();
+ expect(structToTest.buffer.every((v) => v === 0)).toBe(true);
+ });
+
+ test("buffer updated after name set", () => {
+ const structToTest = basicStruct();
+ structToTest.name = "ABCDEF";
+ expect(structToTest.buffer[0]).toBe(0x41);
+ expect(structToTest.buffer[1]).toBe(0x42);
+ expect(structToTest.buffer[2]).toBe(0x43);
+ expect(structToTest.buffer[3]).toBe(0x44);
+ expect(structToTest.buffer[4]).toBe(0x45);
+ expect(structToTest.buffer[5]).toBe(0x46);
+ expect(structToTest.sbyte).toBe(0);
+ expect(structToTest.byte).toBe(0);
+ expect(structToTest.short).toBe(0);
+ expect(structToTest.ushort).toBe(0);
+ expect(structToTest.int).toBe(0);
+ expect(structToTest.uint).toBe(0);
+ expect(structToTest.long).toBe(0n);
+ expect(structToTest.ulong).toBe(0n);
+ });
+
+ test("buffer updated after values set", () => {
+ const structToTest = basicStruct();
+ structToTest.sbyte = 1;
+ structToTest.byte = 2;
+ structToTest.short = 3;
+ structToTest.ushort = 4;
+ structToTest.int = 5;
+ structToTest.uint = 6;
+ structToTest.long = 7n;
+ structToTest.ulong = 8n;
+ expect(structToTest.sbyte).toBe(1);
+ expect(structToTest.byte).toBe(2);
+ expect(structToTest.short).toBe(3);
+ expect(structToTest.ushort).toBe(4);
+ expect(structToTest.int).toBe(5);
+ expect(structToTest.uint).toBe(6);
+ expect(structToTest.long).toBe(7n);
+ expect(structToTest.ulong).toBe(8n);
+ expect(structToTest.buffer.readInt8(16)).toBe(1);
+ expect(structToTest.buffer.readUInt8(17)).toBe(2);
+ expect(structToTest.buffer.readInt16LE(18)).toBe(3);
+ expect(structToTest.buffer.readUInt16LE(20)).toBe(4);
+ expect(structToTest.buffer.readInt32LE(22)).toBe(5);
+ expect(structToTest.buffer.readUInt32LE(26)).toBe(6);
+ expect(structToTest.buffer.readBigInt64LE(30)).toBe(7n);
+ expect(structToTest.buffer.readBigUInt64LE(38)).toBe(8n);
+ });
+});
+
+const structWithArray = newStruct()
+ /* 0 to 7 = 8 */ .array("arr", 4, (b) => b.ushort())
+ .build();
+
+describe("struct with array", () => {
+ test("buffer size", () => {
+ const structToTest = structWithArray();
+ expect(structWithArray.size).toBe(8);
+ expect(structToTest.buffer.byteLength).toBe(8);
+ });
+
+ test("is buffer empty", () => {
+ const structToTest = structWithArray();
+ expect(structToTest.buffer.every((v) => v === 0)).toBe(true);
+ });
+
+ test("check array length", () => {
+ const structToTest = structWithArray();
+ expect(structToTest.arr.length).toBe(4);
+ });
+
+ test("check array values set", () => {
+ const structToTest = structWithArray();
+ structToTest.arr[0] = 1;
+ structToTest.arr[1] = 2;
+ structToTest.arr[2] = 3;
+ structToTest.arr[3] = 4;
+ expect(structToTest.arr[0]).toBe(1);
+ expect(structToTest.arr[1]).toBe(2);
+ expect(structToTest.arr[2]).toBe(3);
+ expect(structToTest.arr[3]).toBe(4);
+ expect(structToTest.buffer.readUInt16LE(0)).toBe(1);
+ expect(structToTest.buffer.readUInt16LE(2)).toBe(2);
+ expect(structToTest.buffer.readUInt16LE(4)).toBe(3);
+ expect(structToTest.buffer.readUInt16LE(6)).toBe(4);
+ });
+});
+
+const structWith2DArray = newStruct()
+ /* 0 to 159 = 160 */ .array("arr", 4, (b) => b.array(10, (b) => b.uint()))
+ .build();
+
+describe("struct with 2D array", () => {
+ test("buffer size", () => {
+ const structToTest = structWith2DArray();
+ expect(structWith2DArray.size).toBe(160);
+ expect(structToTest.buffer.byteLength).toBe(160);
+ });
+
+ test("is buffer empty", () => {
+ const structToTest = structWith2DArray();
+ expect(structToTest.buffer.every((v) => v === 0)).toBe(true);
+ });
+
+ test("check array length", () => {
+ const structToTest = structWith2DArray();
+ expect(structToTest.arr.length).toBe(4);
+ for (const subArr of structToTest.arr) {
+ expect(subArr.length).toBe(10);
+ }
+ });
+});