@nnilky/structo 1.0.0 → 1.0.1

package/package.json

@@ -1,23 +1,47 @@
 {
   "name": "@nnilky/structo",
   "description": "A library for serializing and deserializing binary content",
-  "keywords": ["library"],
+  "keywords": ["binary", "library", "utility", "web", "node"],
   "license": "ISC",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "Ben Brady",
   "private": false,
-  "publishConfig": {
-    "access": "public"
+  "publishConfig": {"access": "public"},
+
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ben-Brady/structo-ts.git"
   },
 
   "readme": "README.md",
-  "main": "structo/index.ts",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    "import": "./structo/index.ts"
+    "./package.json": "./package.json",
+    ".": {
+      "default": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./index.js": {
+      "default": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
-  "files": ["./structo", "package.json"],
+  "files": [
+    "LICENSE",
+    "README.md",
+    "./dist/*.d.ts",
+    "./dist/*.js.map",
+    "./dist/*.js"
+  ],
 
   "scripts": {
+    "build": "tsc",
+    "prepublish": "tsc",
     "check": "tsc --noEmit",
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/structo/datatypes/containers/__snapshots__/list.test.ts.snap

@@ -1,25 +0,0 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`st.list matches snapshots 1`] = `
-ArrayBuffer [
-  3,
-  0,
-  0,
-  0,
-  3,
-  0,
-  102,
-  111,
-  111,
-  3,
-  0,
-  98,
-  97,
-  114,
-  3,
-  0,
-  98,
-  97,
-  122,
-]
-`;

package/structo/datatypes/containers/__snapshots__/object.test.ts.snap

@@ -1,37 +0,0 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`st.object matches snapshots 1`] = `
-ArrayBuffer [
-  1,
-  0,
-  0,
-  0,
-  19,
-  0,
-  0,
-  0,
-  119,
-  111,
-  111,
-  102,
-  32,
-  119,
-  111,
-  111,
-  102,
-  32,
-  98,
-  97,
-  114,
-  107,
-  32,
-  98,
-  97,
-  114,
-  107,
-  19,
-  87,
-  19,
-  83,
-]
-`;

package/structo/datatypes/containers/array.test.ts

@@ -1,28 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { expectEncode, expectError, randint } from "../utils.test";
-
-import * as st from "../../index";
-
-describe("st.array", () => {
-    it("encode correctly", () => {
-        const spec = st.array(4, st.u16());
-        expectEncode(spec, [1, 2, 3, 4]);
-    });
-
-    it("works on empty lists", () => {
-        const spec = st.array(0, st.u16());
-        expectEncode(spec, []);
-    });
-
-    it("throws error on invalid size", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1]));
-    });
-
-    it("throws error on invalid value", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1, -1]));
-        expectError(() => st.write(spec, [2 ** 16 + 1, 0]));
-    });
-});

package/structo/datatypes/containers/array.ts

@@ -1,24 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function array<T>(size: number, type: Serializer<T>): Serializer<T[]> {
-    const { read: readType, write: writeType, size: typeSize } = type;
-
-    return {
-        size: type.size ? size * type.size : undefined,
-        write: (ctx, value) => {
-            if (value.length !== size) throw new Error("Invalid Size");
-
-            if (typeSize) ctx.alloc(size * typeSize);
-            for (let i = 0; i < size; i++) {
-                writeType(ctx, value[i]);
-            }
-        },
-        read: (ctx) => {
-            const arr = new Array(size);
-            for (let i = 0; i < size; i++) {
-                arr[i] = readType(ctx);
-            }
-            return arr;
-        },
-    };
-}

package/structo/datatypes/containers/fastObject.ts

@@ -1,66 +0,0 @@
-import type { InferInput, Serializer } from "../../types";
-
-type InferObject<T> =
-    T extends Record<string, Serializer<any>> ? { [Key in keyof T]: InferInput<T[Key]> } : never;
-
-const definitionSymbol = Symbol();
-
-export function fastObject<T extends Record<string, Serializer<any>>>(
-    definition: T,
-): Serializer<InferObject<T>> {
-    let serializers: [string, Serializer<any>][] = [];
-
-    let writeBody = "";
-    let readBody = "";
-
-    function generateSerializers(serializer: Serializer<any>, keys: string[]) {
-        if (definitionSymbol in serializer) {
-            const definition = serializer[definitionSymbol] as any;
-            readBody += `${keys[keys.length - 1]}: {`;
-            for (const key of Object.keys(definition as any)) {
-                generateSerializers(definition[key], [...keys, key]);
-            }
-            readBody += `},`;
-        } else {
-            let path = "";
-            for (const key of keys) {
-                if (key.match(/[a-zA-Z_][a-zA-Z0-9_]*/)) {
-                    path += `.${key}`;
-                } else {
-                    path += `[${JSON.stringify(key)}]`;
-                }
-            }
-
-            let name = `s${Object.keys(serializers).length}`;
-            serializers.push([name, serializer]);
-            writeBody += `${name}(c, v${path});`;
-            readBody += `${keys[keys.length - 1]}: ${name}(c),`;
-        }
-    }
-
-    for (const key of Object.keys(definition)) {
-        generateSerializers(definition[key], [key]);
-    }
-
-    const writeFactory = new Function(
-        ...serializers.map((v) => v[0]),
-        `return (c, v) => {${writeBody}}`,
-    );
-    const readFactory = new Function(
-        ...serializers.map((v) => v[0]),
-        `return (c, v) => ({${readBody}})`,
-    );
-
-    const write = writeFactory(...serializers.map((v) => v[1].write));
-    const read = readFactory(...serializers.map((v) => v[1].read));
-
-    let size = Object.values(definition).reduce((total, v) => total + (v.size as number), 0);
-
-    return {
-        //@ts-ignore
-        [definitionSymbol]: definition,
-        size: isNaN(size) ? undefined : size,
-        write,
-        read,
-    };
-}

package/structo/datatypes/containers/list.test.ts

@@ -1,44 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randint } from "../utils.test";
-
-import * as st from "../../index";
-
-describe("st.list", () => {
-    it("encode correctly", () => {
-        const spec = st.list({ type: st.u16(), length: st.u8() });
-        expectEncode(spec, [1, 2, 3, 4]);
-    });
-
-    it("works on empty lists", () => {
-        const spec = st.list({ type: st.u16(), length: st.u8() });
-        expectEncode(spec, []);
-    });
-
-    it("throws error on too large array", () => {
-        const spec = st.list({ type: st.u16(), length: st.u8() });
-        expectError(() => {
-            st.write(
-                spec,
-                Array.from({ length: 10000 }, () => 0),
-            );
-        });
-    });
-
-    it("throws error on invalid value", () => {
-        const spec = st.list({ type: st.u16(), length: st.u8() });
-        expectError(() => {
-            st.write(spec, [-1]);
-        });
-    });
-
-    it(`matches snapshots`, () => {
-        expectEncodeSnapshot(
-            st.list({
-                type: st.string(st.u16()),
-                length: st.s32(),
-            }),
-            ["foo", "bar", "baz"],
-        );
-    });
-});

package/structo/datatypes/containers/list.ts

@@ -1,29 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function list<T>(options: {
-    type: Serializer<T>;
-    length: Serializer<number>;
-}): Serializer<T[]> {
-    const { read: readLength, write: writeLength } = options.length;
-    const { read: readType, write: writeType, size: sizeType } = options.type;
-
-    return {
-        write: (ctx, value) => {
-            writeLength(ctx, value.length);
-
-            if (sizeType) ctx.alloc(value.length * sizeType);
-            for (const v of value) {
-                writeType(ctx, v);
-            }
-        },
-        read: (ctx) => {
-            const size = readLength(ctx);
-
-            const arr = new Array(size);
-            for (let i = 0; i < size; i++) {
-                arr[i] = readType(ctx);
-            }
-            return arr;
-        },
-    };
-}

package/structo/datatypes/containers/object.test.ts

@@ -1,42 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
-
-import * as st from "../../index";
-
-describe("st.object", () => {
-    const test = st.object({
-        a: st.u8(),
-        b: st.u8(),
-    });
-
-    it("encodes correctly", () => {
-        st.write(test, { b: 2, a: 1 });
-    });
-
-    it("encode in correct order", () => {
-        const data = st.write(test, { b: 2, a: 1 });
-        const arr = new Uint8Array(data);
-        expect(arr[0]).toBe(1);
-        expect(arr[1]).toBe(2);
-    });
-
-    it("encodes empty", () => {
-        expectEncode(st.object({}), {});
-    });
-
-    it(`matches snapshots`, () => {
-        expectEncodeSnapshot(
-            st.object({
-                number: st.u32(),
-                puppy: st.string(st.s32()),
-                buffer: st.buffer(4),
-            }),
-            {
-                number: 1,
-                puppy: "woof woof bark bark",
-                buffer: bytes([19, 87, 19, 83]),
-            },
-        );
-    });
-});

package/structo/datatypes/containers/object.ts

@@ -1,40 +0,0 @@
-import type { InferInput, InferOutput, Serializer } from "../../types";
-
-type InferObjectInfer<T> =
-    T extends Record<string, Serializer<any>> ? { [Key in keyof T]: InferInput<T[Key]> } : never;
-
-type InferObjectOutput<T> =
-    T extends Record<string, Serializer<any>> ? { [Key in keyof T]: InferOutput<T[Key]> } : never;
-
-export function object<T extends Record<string, Serializer<any>>>(
-    definition: T,
-): Serializer<InferObjectInfer<T>, InferObjectOutput<T>> {
-    const entires = Object.entries(definition);
-
-    // Use the fact: number + undefined = NaN
-    // Check for NaN afterwards
-    let computedSize = Object.values(definition).reduce(
-        (total, v) => total + (v.size as number),
-        0,
-    );
-    const size = isNaN(computedSize) ? undefined : computedSize;
-
-    return {
-        size,
-        write: (ctx, value) => {
-            if (size) ctx.alloc(size);
-
-            for (let i = 0; i < entires.length; i++) {
-                entires[i][1].write(ctx, value[entires[i][0]]);
-            }
-        },
-        read: (ctx) => {
-            const output: [string, unknown][] = new Array(entires.length);
-            for (let i = 0; i < entires.length; i++) {
-                output[i] = [entires[i][0], entires[i][1].read(ctx)];
-            }
-
-            return Object.fromEntries(output) as InferObject<T>;
-        },
-    };
-}

package/structo/datatypes/containers/sizedbuffer.test.ts

@@ -1,34 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectError, randint } from "../utils.test";
-
-import * as st from "../../index";
-
-describe("st.buffer", () => {
-    it("encode correctly", () => {
-        const buffer = st.sizedBuffer(st.u8());
-        expectEncode(buffer, bytes([1, 2]));
-    });
-
-    it("encodes empty correctly", () => {
-        const spec = st.sizedBuffer(st.u8());
-        expectEncode(spec, bytes([]));
-    });
-
-    it("holds large data", () => {
-        const size = 1024 * 1024 * 8; // 8MB
-        const spec = st.sizedBuffer(st.u32());
-
-        const data = new Uint8Array(size);
-        data.set([3, 4], 1000);
-        data.set([3, 4], 2000);
-        expectEncode(spec, data.buffer);
-    });
-
-    it("errors on invalid length", () => {
-        const spec = st.sizedBuffer(st.u8());
-        expectError(() => {
-            st.write(spec, bytes(Array.from({ length: 256 }, () => 0)));
-        });
-    });
-});

package/structo/datatypes/containers/sizedbuffer.ts

@@ -1,20 +0,0 @@
-import type { Serializer } from "../../types";
-
-export function sizedBuffer(length: Serializer<number>): Serializer<ArrayBuffer> {
-    return {
-        write: (ctx, value) => {
-            length.write(ctx, value.byteLength);
-
-            const bytes = new Uint8Array(value);
-            ctx.alloc(value.byteLength);
-            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
-            ctx.offset += value.byteLength;
-        },
-        read: (ctx) => {
-            const size = length.read(ctx);
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
-            ctx.offset += size;
-            return slice;
-        },
-    };
-}

package/structo/datatypes/index.ts

@@ -1,18 +0,0 @@
-export { u64Bigint, s64Bigint } from "./numbers/bigints";
-export { f32, f64 } from "./numbers/floats";
-export { s8, s16, s32, s64 } from "./numbers/sints";
-export { u8, u16, u32, u64 } from "./numbers/uints";
-
-export { array } from "./containers/array";
-export { fastObject } from "./containers/fastObject";
-export { object } from "./containers/object";
-export { list } from "./containers/list";
-export { sizedBuffer } from "./containers/sizedbuffer";
-
-export { string } from "./values/string";
-export { buffer } from "./values/buffer";
-export { byteLiteral } from "./values/byteliteral";
-
-export { type Transform as Pipeline, pipe } from "./transforms/pipe";
-export { positionOffset } from "./transforms/readOffset";
-export { transform } from "./transforms/transform";