@nnilky/structo 1.0.1 → 1.0.3

package/dist/datatypes/values/byteliteral.js

@@ -0,0 +1,20 @@
+export function byteLiteral(bytes) {
+    const length = bytes.length;
+    return {
+        size: bytes.length,
+        read: (ctx) => {
+            const arr = new Uint8Array(ctx.view.buffer);
+            for (let i = 0; i < length; i++) {
+                if (arr[ctx.offset + i] !== bytes[i]) {
+                    throw new Error("Invalid Value");
+                }
+            }
+            ctx.offset += length;
+            return bytes;
+        },
+        write(ctx) {
+            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
+            ctx.offset += length;
+        },
+    };
+}

package/dist/datatypes/values/string.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function string(length: Serializer<number>): Serializer<string>;

package/dist/datatypes/values/string.js

@@ -0,0 +1,22 @@
+export function string(length) {
+    const { read: readLength, write: writeLength, size: lengthSize = 0 } = length;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        write: (ctx, value) => {
+            const bytes = encoder.encode(value);
+            const length = bytes.byteLength;
+            ctx.alloc(length + lengthSize);
+            writeLength(ctx, length);
+            const arr = new Uint8Array(ctx.buffer, ctx.offset);
+            arr.set(bytes);
+            ctx.offset += length;
+        },
+        read: (ctx) => {
+            const length = readLength(ctx);
+            const section = ctx.buffer.slice(ctx.offset, ctx.offset + length);
+            ctx.offset += length;
+            return decoder.decode(section);
+        },
+    };
+}

package/dist/datatypes/values/string.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datatypes/values/string.test.js

@@ -0,0 +1,18 @@
+import { describe, it } from "bun:test";
+import { expectEncode, expectError } from "../utils.test";
+import * as st from "../../index";
+describe("st.string", () => {
+    const string_u8 = st.string(st.u8());
+    const string_u32 = st.string(st.u32());
+    it("encode correctly", () => {
+        expectEncode(string_u8, "foo");
+    });
+    it("works on empty strings", () => {
+        expectEncode(string_u32, "");
+    });
+    it("errors on too long strings", () => {
+        expectError(() => {
+            st.write(string_u8, "A".repeat(256));
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { InferInput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types";
+export * from "./datatypes";
+export { read, createReaderContext } from "./read";
+export { write, createdWriterContext } from "./write";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./datatypes";
+export { read, createReaderContext } from "./read";
+export { write, createdWriterContext } from "./write";

package/dist/read.d.ts

@@ -0,0 +1,7 @@
+import type { Serializer } from "./types";
+export declare function read<T>(serializer: Serializer<T>, buffer: ArrayBuffer): T;
+export declare function createReaderContext(buffer: ArrayBuffer): {
+    offset: number;
+    buffer: ArrayBuffer;
+    view: DataView<ArrayBuffer>;
+};

package/dist/read.js

@@ -0,0 +1,10 @@
+export function read(serializer, buffer) {
+    return serializer.read(createReaderContext(buffer));
+}
+export function createReaderContext(buffer) {
+    return {
+        offset: 0,
+        buffer,
+        view: new DataView(buffer),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type Serializer<TIn, TOut = TIn> = {
+    size?: number | undefined;
+    write: (ctx: WriterContext, value: TIn) => void;
+    read: (ctx: ReaderContext) => TOut;
+};
+export interface WriterContext {
+    buffer: ArrayBuffer;
+    view: DataView;
+    offset: number;
+    alloc: (length: number) => void;
+}
+export interface ReaderContext {
+    buffer: ArrayBuffer;
+    view: DataView;
+    offset: number;
+}
+export type InferInput<T> = T extends Serializer<infer V> ? V : never;
+export type InferOutput<T> = T extends Serializer<any, infer V> ? V : never;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils.test.js

@@ -0,0 +1 @@
+export {};

package/dist/write.d.ts

@@ -0,0 +1,3 @@
+import type { WriterContext, Serializer } from "./types";
+export declare function write<T>(serializer: Serializer<T>, value: T): ArrayBuffer;
+export declare function createdWriterContext(type: Serializer<any>): WriterContext;

package/dist/write.js

@@ -0,0 +1,43 @@
+export function write(serializer, value) {
+    const ctx = createdWriterContext(serializer);
+    serializer.write(ctx, value);
+    if (ctx.buffer.byteLength === ctx.offset) {
+        return ctx.buffer;
+    }
+    else {
+        return ctx.buffer.transfer(ctx.offset);
+    }
+}
+export function createdWriterContext(type) {
+    if (type.size) {
+        let buffer = new ArrayBuffer(type.size);
+        const view = new DataView(buffer);
+        return {
+            offset: 0,
+            buffer,
+            view,
+            alloc: Function.prototype,
+        };
+    }
+    else {
+        let bufferLength = 128;
+        let buffer = new ArrayBuffer(bufferLength, { maxByteLength: 1024 });
+        const view = new DataView(buffer);
+        return {
+            offset: 0,
+            buffer,
+            view,
+            alloc(length) {
+                if (length < 0)
+                    return;
+                if (buffer.resizable) {
+                }
+                while (this.offset + length > bufferLength) {
+                    bufferLength = bufferLength * 2;
+                    this.buffer.resize(bufferLength);
+                    this.view = new DataView(this.buffer);
+                }
+            },
+        };
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "A library for serializing and deserializing binary content",
   "keywords": ["binary", "library", "utility", "web", "node"],
   "license": "ISC",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {"access": "public"},
@@ -34,9 +34,9 @@
   "files": [
     "LICENSE",
     "README.md",
-    "./dist/*.d.ts",
-    "./dist/*.js.map",
-    "./dist/*.js"
+    "./dist/**/*.d.ts",
+    "./dist/**/*.js.map",
+    "./dist/**/*.js"
   ],
 
   "scripts": {