@anterior/brrr 0.1.1

package/src/tagged-tuple.test.ts

@@ -0,0 +1,69 @@
+import { suite, test } from "node:test";
+import { deepStrictEqual, ok } from "node:assert/strict";
+import { throws } from "node:assert";
+import { MalformedTaggedTupleError, TagMismatchError } from "./errors.ts";
+import { TaggedTuple } from "./tagged-tuple.ts";
+
+await suite(import.meta.filename, async () => {
+  class Foo {
+    public static readonly tag = 0;
+
+    public readonly bar: number;
+    public readonly baz: string;
+
+    public constructor(foo: number, bar: string) {
+      this.bar = foo;
+      this.baz = bar;
+    }
+  }
+
+  await suite("fromTuple", async () => {
+    await test("create instance", async () => {
+      const foo = TaggedTuple.fromTuple(Foo, [0, 42, "hello"]);
+      ok(foo instanceof Foo);
+      ok(foo.bar === 42);
+      ok(foo.baz === "hello");
+    });
+    await test("tag mismatch", async () => {
+      throws(
+        () => TaggedTuple.fromTuple(Foo, [1, 42, "hello"]),
+        TagMismatchError,
+      );
+    });
+    await test("too many args", async () => {
+      throws(
+        // @ts-expect-error testing runtime error
+        () => TaggedTuple.fromTuple(Foo, [0, 42, "hello", "a"]),
+        MalformedTaggedTupleError,
+      );
+    });
+    await test("too few args", async () => {
+      throws(
+        // @ts-expect-error testing runtime error
+        () => TaggedTuple.fromTuple(Foo, [0, 42]),
+        MalformedTaggedTupleError,
+      );
+    });
+  });
+
+  await suite("asTuple", async () => {
+    await test("basic", async () => {
+      const foo: Foo = TaggedTuple.fromTuple(Foo, [0, 42, "hello"]);
+      deepStrictEqual(TaggedTuple.asTuple(foo), [0, 42, "hello"]);
+    });
+  });
+
+  await suite("encode and decode", async () => {
+    const foo: Foo = TaggedTuple.fromTuple(Foo, [0, 42, "hello"]);
+    const encoded: Uint8Array = TaggedTuple.encode(foo);
+    const decoded = TaggedTuple.decode(Foo, encoded);
+    deepStrictEqual(decoded, foo);
+  });
+
+  await suite("encode and decode (string)", async () => {
+    const foo: Foo = TaggedTuple.fromTuple(Foo, [0, 42, "hello"]);
+    const encoded: string = TaggedTuple.encodeToString(foo);
+    const decoded = TaggedTuple.decodeFromString(Foo, encoded);
+    deepStrictEqual(decoded, foo);
+  });
+});

package/src/tagged-tuple.ts

@@ -0,0 +1,96 @@
+import { bencoder, decoder, encoder, encoding } from "./internal-codecs.ts";
+import { MalformedTaggedTupleError, TagMismatchError } from "./errors.ts";
+
+export interface Tagged<T = any, A extends unknown[] = any[]> {
+  new (...args: A): T;
+
+  readonly tag: number;
+}
+
+function fromTuple<T, A extends unknown[]>(
+  tagged: Tagged<T, A>,
+  data: [number, ...A],
+): InstanceType<typeof tagged> {
+  if (data[0] !== tagged.tag) {
+    throw new TagMismatchError(tagged);
+  }
+  if (data.length - 1 !== tagged.length) {
+    throw new MalformedTaggedTupleError(tagged);
+  }
+  return new tagged(...(data.slice(1) as A));
+}
+
+function asTuple<T extends object, A extends unknown[]>(
+  obj: InstanceType<Tagged<T, A>>,
+): [number, ...A] {
+  return [(obj.constructor as Tagged<T, A>).tag, ...Object.values(obj)] as [
+    number,
+    ...A,
+  ];
+}
+
+function encode(obj: InstanceType<Tagged>): Uint8Array {
+  return bencoder.encode(asTuple(obj));
+}
+
+function encodeToString(obj: InstanceType<Tagged>): string {
+  return decoder.decode(encode(obj));
+}
+
+function decode<T, A extends unknown[]>(
+  tagged: Tagged<T, A>,
+  data: Uint8Array,
+): InstanceType<typeof tagged> {
+  const decoded = bencoder.decode(data, encoding) as [number, ...A];
+  return fromTuple(tagged, decoded);
+}
+
+function decodeFromString<T, A extends unknown[]>(
+  tagged: Tagged<T, A>,
+  data: string,
+): InstanceType<typeof tagged> {
+  return decode(tagged, encoder.encode(data));
+}
+
+export const TaggedTuple = {
+  fromTuple,
+  asTuple,
+  encode,
+  encodeToString,
+  decode,
+  decodeFromString,
+} as const;
+
+export class PendingReturn {
+  public static readonly tag = 1;
+
+  public readonly rootId: string;
+  public readonly callHash: string;
+  public readonly topic: string;
+
+  constructor(rootId: string, callHash: string, topic: string) {
+    this.rootId = rootId;
+    this.callHash = callHash;
+    this.topic = topic;
+  }
+
+  public isRepeatedCall(other: PendingReturn): boolean {
+    return (
+      this.rootId !== other.rootId &&
+      this.callHash === other.callHash &&
+      this.topic === other.topic
+    );
+  }
+}
+
+export class ScheduleMessage {
+  public static readonly tag = 2;
+
+  public readonly rootId: string;
+  public readonly callHash: string;
+
+  constructor(rootId: string, callHash: string) {
+    this.rootId = rootId;
+    this.callHash = callHash;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    /* Base Options */
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "target": "esnext",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "preserveSymlinks": true,
+
+    /* Strictness */
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noUncheckedSideEffectImports": true,
+    "noImplicitOverride": true,
+    "exactOptionalPropertyTypes": true,
+    "useUnknownInCatchVariables": true,
+
+    /* Module Resolution */
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "lib": ["esnext"],
+
+    /* Build */
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "incremental": true
+  },
+  "include": ["src/**/*.ts"]
+}