liminal 0.4.0 → 1.0.0-beta.2

package/src/core/Struct.ts

@@ -0,0 +1,49 @@
+import { Flatten } from "../util/Flatten.js"
+import { isKey } from "../util/isKey.js"
+import { Key } from "./Key.js"
+import { Factory, Type, TypeSource } from "./Type.js"
+
+export interface Struct<F extends FieldTypes = any>
+  extends InstanceType<ReturnType<typeof Struct<F>>>
+{}
+
+export function Struct<const F extends FieldTypes>(fieldTypes: F) {
+  return class extends Type.make("Struct")<StructSource, StructNative<F>, StructFrom<F>> {
+    fieldTypes = fieldTypes
+    fields = Object.fromEntries(
+      Object.entries(fieldTypes).map(([key, type]) => [
+        key,
+        new (isKey(type) ? Key(type) : type)(
+          new TypeSource.StructField(this, key),
+        ),
+      ]),
+    ) as Fields<F>
+  }
+}
+
+export type FieldType = keyof any | Factory
+export type FieldTypes = Record<string, FieldType>
+
+export type Fields<F extends FieldTypes = any> = {
+  -readonly [K in keyof F]: F[K] extends keyof any ? Key<F[K]>
+    : F[K] extends Factory ? InstanceType<F[K]>
+    : never
+}
+
+export type StructFrom<F extends FieldTypes = any> = F extends Record<string, keyof any> ? undefined
+  : {
+    -readonly [K in keyof F as F[K] extends Factory ? K : never]: F[K] extends Factory<infer T>
+      ? T | Type.Native<T>
+      : never
+  }
+
+type StructNativeField<T> = T extends Factory<infer U> ? Type.Native<U> : T
+export type StructNative<F extends FieldTypes> = Flatten<
+  { -readonly [K in keyof F]: StructNativeField<F[K]> }
+>
+
+export type StructField<T> = T extends keyof any ? Key<T>
+  : T extends Factory ? InstanceType<T>
+  : never
+
+export type StructSource = never

package/src/core/Type.ts

@@ -0,0 +1,120 @@
+import { Rest } from "../util/Rest.js"
+import { Tagged } from "../util/Tagged.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { bool, BoolSource } from "./Bool.js"
+import { GenCall, Result, ValueCall, Yield } from "./Call.js"
+import { Effect } from "./Effect.js"
+import { State } from "./State.js"
+
+export type Factory<T extends Type = any> = new(source: any) => T
+
+export class Type<
+  Name extends string = any,
+  Source = any,
+  Native = any,
+  From = any,
+  Into extends Type = any,
+> {
+  declare ""?: [Native, From, Into]
+
+  static make<Name extends string>(name: Name) {
+    return class<Source, Native = never, From = Native, Into extends Type = never>
+      extends this<Name, Source, Native, From, Into>
+    {
+      constructor(source: Source | TypeSource) {
+        super(name, source)
+      }
+    }
+  }
+
+  static new<T extends Type>(this: Factory<T>, ...[value]: Rest<Type.From<T>>): T {
+    return new this(new TypeSource.New(value))
+  }
+
+  static state<T extends Type>(this: Factory<T>): State<T> {
+    return State(this)
+  }
+
+  constructor(readonly typeName: Name, readonly source: Source | TypeSource) {}
+
+  ctor = this.constructor as never as new(source: Source | TypeSource) => this
+
+  into<O extends Into>(into: Factory<O>): O {
+    return new into(new TypeSource.Into({ from: this }))
+  }
+
+  equals<T extends Type>(this: T, inQuestion: T): bool {
+    return new bool(new BoolSource.Equals(this, inQuestion))
+  }
+
+  is<T extends Type, M extends Factory<T>>(this: T, match: M): bool {
+    return new bool(new BoolSource.Is(this, match))
+  }
+
+  case<
+    T extends Type,
+    M extends Factory<T>,
+    R extends Result,
+    U extends Exclude<T, InstanceType<M>> | R,
+  >(
+    this: T,
+    match: M,
+    f: ValueCall<R, [InstanceType<M>]>,
+  ): U
+  case<
+    T extends Type,
+    M extends Factory<T>,
+    Y extends Yield,
+    R extends Result,
+    U extends Exclude<T, InstanceType<M>> | R,
+  >(
+    this: T,
+    match: M,
+    f: GenCall<Y, R, [InstanceType<M>]>,
+  ): Effect<Y, U>
+  case(_match: any, _f: any): any {
+    unimplemented()
+  }
+
+  "?"<T extends Type, M extends Factory<T>>(
+    this: T,
+    match: M,
+  ): Effect<InstanceType<M>, Exclude<T, InstanceType<M>>>
+  "?"<T extends Type, M extends Factory<T>, W extends Type>(
+    this: T,
+    match: M,
+    with_: W,
+  ): Effect<W, Exclude<T, InstanceType<M>>>
+  "?"<T extends Type>(
+    this: T,
+    _match: Factory<T>,
+    _maybeWith_?: Type,
+  ) {
+    return unimplemented()
+  }
+}
+
+export declare namespace Type {
+  export type From<T> = T extends Type<any, any, any, infer From> ? From : never
+  export type Native<T extends Type | void> = T extends Type<any, any, infer N> ? N : undefined
+  export type Source<T extends Type> = T extends Type<any, infer S> ? S : never
+}
+
+export type TypeSource = TypeSource.New | TypeSource.Into | TypeSource.StructField
+export namespace TypeSource {
+  export class New extends Tagged("New") {
+    constructor(readonly from: unknown) {
+      super()
+    }
+  }
+  export class Into extends Tagged("Into") {
+    constructor(readonly from: unknown) {
+      super()
+    }
+  }
+  export class StructField extends Tagged("StructField") {
+    constructor(readonly self: Type, readonly key: keyof any) {
+      super()
+    }
+  }
+}

package/src/core/Union.ts

@@ -0,0 +1,17 @@
+import { MerkleListSource } from "./MerkleList.js"
+import { MerkleMapSource } from "./MerkleMap.js"
+import { Factory, Type } from "./Type.js"
+
+export interface Union<T extends Factory[] = any> extends ReturnType<typeof Union<T>> {}
+
+export function Union<T extends Factory[]>(...members: T) {
+  return class extends Type.make("Union")<
+    UnionSource,
+    Type.Native<InstanceType<T[number]>>,
+    Type.Native<InstanceType<T[number]>> | InstanceType<T[number]>
+  > {
+    members = members
+  }
+}
+
+export type UnionSource = MerkleMapSource.Get | MerkleListSource.At

package/src/core/Use.ts

@@ -0,0 +1,33 @@
+import { Flatten } from "../util/Flatten.js"
+import { Tagged } from "../util/Tagged.js"
+import { U2I } from "../util/U2I.js"
+import { unimplemented } from "../util/unimplemented.js"
+import { Yield } from "./Call.js"
+import { Factory, Type } from "./Type.js"
+import { Union } from "./Union.js"
+
+export type UseField = Factory
+export type UseFieldTypes = Record<string, UseField>
+export type UseFields<F extends UseFieldTypes = any> = { [K in keyof F]: InstanceType<F[K]> }
+
+export function use<F extends UseFieldTypes>(
+  _fields: F,
+): Generator<
+  Use<Flatten<UseFields<F>>>,
+  Flatten<
+    { [K in keyof F]: F[K] extends Union<infer U> ? InstanceType<U[number]> : InstanceType<F[K]> }
+  >
+> {
+  unimplemented()
+}
+
+export class Use<F extends UseFields = any> extends Type.make("Dependencies")<UseSource> {
+  constructor(readonly fields: F) {
+    super(new UseSource())
+  }
+}
+
+export class UseSource extends Tagged("UseSource") {}
+
+export type ExtractUse<Y extends Yield> = Extract<Y, Use> extends Use<infer D> ? Flatten<U2I<D>>
+  : never

package/src/core/mod.ts

@@ -0,0 +1,19 @@
+// moderate
+
+export * from "./Bool.js"
+export * from "./Bytes.js"
+export * from "./Call.js"
+export * from "./Effect.js"
+export * from "./Hash.js"
+export * from "./Id.js"
+export * from "./Int.js"
+export * from "./Key.js"
+export * from "./MerkleList.js"
+export * from "./MerkleMap.js"
+export * from "./None.js"
+export * from "./State.js"
+export * from "./String.js"
+export * from "./Struct.js"
+export * from "./Type.js"
+export * from "./Union.js"
+export * from "./Use.js"

package/src/lib/MerkleList.ts

@@ -0,0 +1,4 @@
+// TODO
+export class MerkleList<T> {
+  declare ""?: [T]
+}

package/src/lib/MerkleMap.ts

@@ -0,0 +1,4 @@
+// TODO
+export class MerkleMap<K, V> {
+  declare ""?: [K, V]
+}

package/src/lib/mod.ts

@@ -0,0 +1,2 @@
+export * from "./MerkleList.js"
+export * from "./MerkleMap.js"

package/src/mod.ts

@@ -0,0 +1,4 @@
+// moderate --exclude lib test
+
+export * from "./client/mod.js"
+export * from "./core/mod.js"

package/src/test/Signer.ts

@@ -0,0 +1,22 @@
+import crypto from "node:crypto"
+import { ArrayOfLength } from "../util/ArrayOfLength.js"
+
+export function signer(): TestSigner
+export function signer(count: 1): TestSigner
+export function signer<C extends number>(count: C): ArrayOfLength<TestSigner, C>
+export function signer(count?: number): TestSigner | TestSigner[] {
+  if (!count || count === 1) return TestSigner()
+  return Array.from({ length: count }, TestSigner)
+}
+
+export interface TestSigner {
+  publicKey: Uint8Array
+  (tx: Uint8Array): Uint8Array
+}
+
+// TODO: get signing actually working at some point
+export function TestSigner(): TestSigner {
+  const pair = crypto.generateKeyPairSync("ec", { namedCurve: "secp256k1" })
+  const publicKey = new Uint8Array(pair.publicKey.export({ format: "der", type: "sec1" }))
+  return Object.assign((tx: Uint8Array) => crypto.sign(null, tx, pair.privateKey), { publicKey })
+}

package/src/test/mod.ts

@@ -0,0 +1 @@
+export * from "./Signer.js"

package/src/util/AbortController.ts

@@ -0,0 +1,3 @@
+export interface SignalOptions {
+  signal?: AbortSignal
+}

package/src/util/ArrayOfLength.ts

@@ -0,0 +1,5 @@
+export type ArrayOfLength<
+  T,
+  L extends number,
+  A extends T[] = [],
+> = number extends L ? T[] : L extends A["length"] ? A : ArrayOfLength<T, L, [...A, T]>

package/src/util/Flatten.ts

@@ -0,0 +1,2 @@
+// TODO: adjust for misc. native datatypes
+export type Flatten<T> = [{ [K in keyof T]: T[K] }][0]

package/src/util/Rest.ts

@@ -0,0 +1 @@
+export type Rest<T> = undefined extends T ? [value?: T] : [value: T]

package/src/util/Subscription.ts

@@ -0,0 +1,5 @@
+import { SignalOptions } from "./AbortController.js"
+
+export interface Subscription<T> {
+  subscribe(callback: (value: T) => void, options?: SignalOptions): Promise<void>
+}

package/src/util/Tagged.ts

@@ -0,0 +1,5 @@
+export function Tagged<K extends keyof any>(tag: K) {
+  return class {
+    readonly tag = tag
+  }
+}

package/src/util/U2I.ts

@@ -0,0 +1 @@
+export type U2I<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never

package/src/util/generator/collect.ts

@@ -0,0 +1,16 @@
+export type Collected<Y, R> = [Y[], R]
+
+export function collect<Y, R>(generator: Generator<Y, R>): Collected<Y, R> {
+  const statements: Y[] = []
+  let result: R
+  statements: while (true) {
+    const next = generator.next()
+    if (next.done) {
+      result = next.value
+      break statements
+    } else {
+      statements.push(next.value)
+    }
+  }
+  return [statements, result]
+}

package/src/util/isKey.ts

@@ -0,0 +1,7 @@
+export function isKey(inQuestion: unknown): inQuestion is keyof any {
+  return !!({
+    number: true,
+    string: true,
+    symbol: true,
+  } as Record<string, boolean>)[typeof inQuestion]
+}

package/src/util/unimplemented.ts

@@ -0,0 +1,4 @@
+export function unimplemented(message?: string): never {
+  if (message) console.error(message)
+  throw 0
+}

package/jest.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-}

package/lib/array/array.d.ts

@@ -1,6 +0,0 @@
-export declare const filter: (fn: any) => (arr: any) => any;
-export declare const map: (fn: any) => (arr: any) => any;
-export declare const reduce: (fn: any, initialValue: any) => (arr: any) => any;
-export declare const reduceRight: (fn: any, initialValue: any) => (arr: any) => any;
-export declare const reverse: (arr: any) => any;
-export declare const sort: (fn: any) => (arr: any) => any[];

package/lib/array/array.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filter = (fn) => (arr) => arr.filter(fn);
-exports.map = (fn) => (arr) => arr.map(fn);
-exports.reduce = (fn, initialValue) => (arr) => arr.reduce(fn, initialValue);
-exports.reduceRight = (fn, initialValue) => (arr) => arr.reduceRight(fn, initialValue);
-exports.reverse = (arr) => arr.reverse();
-exports.sort = (fn) => (arr) => {
-    if (fn) {
-        return [...arr].sort(fn);
-    }
-    if (typeof arr[0] === 'number') {
-        return [...arr].sort((a, b) => a - b);
-    }
-    if (typeof arr[0] === 'bigint') {
-        return [...arr].sort((a, b) => {
-            return 1;
-        });
-    }
-    return [...arr].sort();
-};

package/lib/array/index.d.ts

@@ -1,11 +0,0 @@
-import { filter, map, reduce, reduceRight, reverse, sort } from './array';
-export { filter, map, reduce, reduceRight, reverse, sort };
-declare const _default: {
-    filter: (fn: any) => (arr: any) => any;
-    map: (fn: any) => (arr: any) => any;
-    reduce: (fn: any, initialValue: any) => (arr: any) => any;
-    reduceRight: (fn: any, initialValue: any) => (arr: any) => any;
-    reverse: (arr: any) => any;
-    sort: (fn: any) => (arr: any) => any[];
-};
-export default _default;

package/lib/array/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const array_1 = require("./array");
-exports.filter = array_1.filter;
-exports.map = array_1.map;
-exports.reduce = array_1.reduce;
-exports.reduceRight = array_1.reduceRight;
-exports.reverse = array_1.reverse;
-exports.sort = array_1.sort;
-exports.default = {
-    filter: array_1.filter,
-    map: array_1.map,
-    reduce: array_1.reduce,
-    reduceRight: array_1.reduceRight,
-    reverse: array_1.reverse,
-    sort: array_1.sort,
-};

package/lib/composition/composition.d.ts

@@ -1,6 +0,0 @@
-import { ChainFunctions } from './types';
-declare const compose: ChainFunctions;
-declare const pipe: ChainFunctions;
-declare const rail: ChainFunctions;
-declare const railSync: ChainFunctions;
-export { compose, pipe, rail, railSync };

package/lib/composition/composition.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const array_1 = require("../array");
-const wrapSync = (fn) => (input) => {
-    if (input instanceof Error) {
-        return input;
-    }
-    let result;
-    try {
-        result = fn(input);
-    }
-    catch (error) {
-        result = error;
-    }
-    return typeof result === 'undefined' ? input : result;
-};
-const wrap = (fn) => (input) => {
-    if (input instanceof Promise) {
-        return input.then((rawInput) => {
-            return wrapSync(fn)(rawInput);
-        });
-    }
-    return wrapSync(fn)(input);
-};
-const chain = (reducingFn, wrappingFn = null) => (...fns) => (initialArg) => {
-    return wrappingFn
-        ? reducingFn((arg, fn) => wrappingFn(fn)(arg), initialArg)(fns)
-        : reducingFn((arg, fn) => fn(arg), initialArg)(fns);
-};
-const compose = chain(array_1.reduceRight);
-exports.compose = compose;
-const pipe = chain(array_1.reduce);
-exports.pipe = pipe;
-const rail = chain(array_1.reduce, wrap);
-exports.rail = rail;
-const railSync = chain(array_1.reduce, wrapSync);
-exports.railSync = railSync;

package/lib/composition/index.d.ts

@@ -1,9 +0,0 @@
-import { compose, pipe, rail, railSync } from './composition';
-export { compose, pipe, rail, railSync };
-declare const _default: {
-    compose: import("./types").ChainFunctions;
-    pipe: import("./types").ChainFunctions;
-    rail: import("./types").ChainFunctions;
-    railSync: import("./types").ChainFunctions;
-};
-export default _default;

package/lib/composition/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const composition_1 = require("./composition");
-exports.compose = composition_1.compose;
-exports.pipe = composition_1.pipe;
-exports.rail = composition_1.rail;
-exports.railSync = composition_1.railSync;
-exports.default = {
-    compose: composition_1.compose,
-    pipe: composition_1.pipe,
-    rail: composition_1.rail,
-    railSync: composition_1.railSync,
-};

package/lib/composition/types.d.ts

@@ -1,2 +0,0 @@
-export declare type ChainFunctions = (...fns: Function[]) => (initialArg: any) => any;
-export declare type ChainFactory = (reduceFn: Function, wrappingFn?: Function) => ChainFunctions;

package/lib/composition/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dispatch/getType.d.ts

@@ -1,2 +0,0 @@
-declare const getType: (val: any) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null" | "regexp";
-export default getType;

package/lib/dispatch/getType.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getType = (val) => {
-    if (Array.isArray(val)) {
-        return 'array';
-    }
-    if (val === null) {
-        return 'null';
-    }
-    if (val instanceof RegExp) {
-        return 'regexp';
-    }
-    return typeof val;
-};
-exports.default = getType;

package/lib/dispatch/identity.d.ts

@@ -1,2 +0,0 @@
-declare const identity: (x: any) => any;
-export default identity;

package/lib/dispatch/identity.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const identity = (x) => x;
-exports.default = identity;

package/lib/dispatch/index.d.ts

@@ -1,22 +0,0 @@
-import getType from './getType';
-import identity from './identity';
-import types from './types';
-export { getType, identity, types };
-declare const _default: {
-    getType: (val: any) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null" | "regexp";
-    identity: (x: any) => any;
-    types: {
-        array: string;
-        object: string;
-        function: string;
-        string: string;
-        number: string;
-        bigint: string;
-        symbol: string;
-        regexp: string;
-        null: string;
-        undefined: string;
-        boolean: string;
-    };
-};
-export default _default;

package/lib/dispatch/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getType_1 = require("./getType");
-exports.getType = getType_1.default;
-const identity_1 = require("./identity");
-exports.identity = identity_1.default;
-const types_1 = require("./types");
-exports.types = types_1.default;
-exports.default = {
-    getType: getType_1.default,
-    identity: identity_1.default,
-    types: types_1.default,
-};

package/lib/dispatch/types.d.ts

@@ -1,14 +0,0 @@
-declare const types: {
-    array: string;
-    object: string;
-    function: string;
-    string: string;
-    number: string;
-    bigint: string;
-    symbol: string;
-    regexp: string;
-    null: string;
-    undefined: string;
-    boolean: string;
-};
-export default types;

package/lib/dispatch/types.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types = {
-    array: 'array',
-    object: 'object',
-    function: 'function',
-    string: 'string',
-    number: 'number',
-    bigint: 'bigint',
-    symbol: 'symbol',
-    regexp: 'regexp',
-    null: 'null',
-    undefined: 'undefined',
-    boolean: 'boolean',
-};
-exports.default = types;

package/lib/error/error.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="node" />
-declare const _default: {
-    create: ({ name, defaultMessage }: {
-        name: any;
-        defaultMessage?: string;
-    }) => {
-        new (message?: string): {
-            name: string;
-            message: string;
-            stack?: string;
-        };
-        captureStackTrace(targetObject: Object, constructorOpt?: Function): void;
-        prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;
-        stackTraceLimit: number;
-    };
-    toJSON: (error: any) => {
-        error: {
-            name: any;
-            message: any;
-            stacktrace: any;
-        };
-    };
-};
-export default _default;

package/lib/error/error.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const create = ({ name, defaultMessage = '' }) => {
-    const err = class extends Error {
-        constructor(message = defaultMessage) {
-            super(message);
-            this.name = name;
-            this.message = message;
-        }
-    };
-    return err;
-};
-const toJSON = (error) => {
-    return {
-        error: {
-            name: error.name,
-            message: error.message,
-            stacktrace: error.stack,
-        },
-    };
-};
-exports.default = {
-    create,
-    toJSON,
-};