@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/stdlib/encode.ts

@@ -0,0 +1,259 @@
+import { type Bind, type Kind3, type TypeLambda } from 'sts:hkt';
+import { Failure } from 'sts:failures';
+import { err, isErr, isOk, isSome, ok, type Option, type Result } from 'sts:result';
+import type { Contravariant } from 'sts:typeclasses';
+
+export class EncodeFailure extends Failure {
+  constructor(message = 'Failed to encode value.', cause?: unknown) {
+    super(message, { cause });
+  }
+}
+
+// #[variance(T: in, TEncoded: out, E: out)]
+export type Encoder<T, TEncoded = unknown, E = EncodeFailure> = {
+  encode(value: T): Result<TEncoded, E>;
+};
+
+// #[variance(T: in, TEncoded: out, E: out)]
+export type OptionalEncoder<T, TEncoded = T, E = EncodeFailure> =
+  Encoder<T | undefined, TEncoded | undefined, E> & {
+    readonly __soundscriptOptional: true;
+    readonly inner: Encoder<T, TEncoded, E>;
+  };
+
+type EncoderInput<TEncoder> = TEncoder extends Encoder<infer T, unknown, unknown> ? T : never;
+type EncoderOutput<TEncoder> = TEncoder extends Encoder<unknown, infer TEncoded, unknown> ? TEncoded
+  : never;
+type EncoderError<TEncoder> = TEncoder extends Encoder<unknown, unknown, infer E> ? E : never;
+type ObjectShape = Record<string, Encoder<unknown, unknown, unknown>>;
+type TupleShape = readonly Encoder<unknown, unknown, unknown>[];
+
+export interface EncoderF extends TypeLambda {
+  readonly type: Encoder<this['Args'][2], this['Args'][1], this['Args'][0]>;
+}
+
+export type EncoderKind<E, TEncoded, T> = Kind3<EncoderF, E, TEncoded, T>;
+
+export function fromEncode<T, TEncoded, E>(
+  encode: (value: T) => Result<TEncoded, E>,
+): Encoder<T, TEncoded, E> {
+  return {
+    encode,
+  };
+}
+
+export function contramap<A, B, TEncoded, E>(
+  encoder: Encoder<A, TEncoded, E>,
+  project: (value: B) => A,
+): Encoder<B, TEncoded, E> {
+  return fromEncode((value) => encoder.encode(project(value)));
+}
+
+export function encoderContravariant<TEncoded, E = EncodeFailure>(): Contravariant<
+  Bind<Bind<EncoderF, [E]>, [TEncoded]>
+> {
+  return {
+    contramap,
+  };
+}
+
+export const stringEncoder: Encoder<string, string> = fromEncode((value) => ok(value));
+export const numberEncoder: Encoder<number, number> = fromEncode((value) => ok(value));
+export const booleanEncoder: Encoder<boolean, boolean> = fromEncode((value) => ok(value));
+export const bigintEncoder: Encoder<bigint, bigint> = fromEncode((value) => ok(value));
+
+export function optional<T, TEncoded, E>(
+  encoder: Encoder<T, TEncoded, E>,
+): OptionalEncoder<T, TEncoded, E> {
+  return {
+    __soundscriptOptional: true,
+    inner: encoder,
+    encode(value) {
+      return value === undefined ? ok(undefined) : encoder.encode(value);
+    },
+  };
+}
+
+export function lazy<T, TEncoded, E>(
+  getEncoder: () => Encoder<T, TEncoded, E>,
+): Encoder<T, TEncoded, E> {
+  return fromEncode((value) => getEncoder().encode(value));
+}
+
+export function nullable<T, TEncoded, E>(
+  encoder: Encoder<T, TEncoded, E>,
+): Encoder<T | null, TEncoded | null, E> {
+  return fromEncode((value) => value === null ? ok(null) : encoder.encode(value));
+}
+
+export function literal<const T extends string | number | boolean | null>(value: T): Encoder<T, T> {
+  return fromEncode((input) =>
+    Object.is(input, value)
+      ? ok(value)
+      : err(new EncodeFailure(`Expected literal ${JSON.stringify(value)}.`, input))
+  );
+}
+
+export function array<T, TEncoded, E>(
+  item: Encoder<T, TEncoded, E>,
+): Encoder<readonly T[], readonly TEncoded[], E | EncodeFailure> {
+  return fromEncode((value) => {
+    const encodedValues: TEncoded[] = [];
+    for (const entry of value) {
+      const encoded = item.encode(entry);
+      if (isErr(encoded)) {
+        return encoded;
+      }
+      encodedValues.push(encoded.value);
+    }
+    return ok(encodedValues);
+  });
+}
+
+export function tuple<const TElements extends TupleShape>(
+  ...elements: TElements
+): Encoder<
+  { readonly [K in keyof TElements]: EncoderInput<TElements[K]> },
+  { readonly [K in keyof TElements]: EncoderOutput<TElements[K]> },
+  EncoderError<TElements[number]>
+> {
+  return fromEncode((value) => {
+    const values = value as readonly unknown[];
+    const encodedValues: unknown[] = [];
+    for (let index = 0; index < elements.length; index += 1) {
+      const elementEncoder = elements[index];
+      if (!elementEncoder) {
+        continue;
+      }
+      const encoded = elementEncoder.encode(values[index] as never);
+      if (isErr(encoded)) {
+        return encoded as Result<
+          { readonly [K in keyof TElements]: EncoderOutput<TElements[K]> },
+          EncoderError<TElements[number]>
+        >;
+      }
+      encodedValues.push(encoded.value);
+    }
+    return ok(encodedValues as { readonly [K in keyof TElements]: EncoderOutput<TElements[K]> });
+  });
+}
+
+export function option<T, TEncoded, E>(
+  item: Encoder<T, TEncoded, E>,
+): Encoder<
+  Option<T>,
+  { readonly tag: 'none' } | {
+    readonly tag: 'some';
+    readonly value: TEncoded;
+  },
+  E
+> {
+  return fromEncode<
+    Option<T>,
+    { readonly tag: 'none' } | {
+      readonly tag: 'some';
+      readonly value: TEncoded;
+    },
+    E
+  >((value) => {
+    if (isSome(value)) {
+      const encoded = item.encode(value.value);
+      return isErr(encoded) ? encoded : ok({ tag: 'some', value: encoded.value });
+    }
+
+    return ok({ tag: 'none' });
+  });
+}
+
+export function result<T, EValue, TEncoded, EEncoded, EOk, EErr>(
+  okEncoder: Encoder<T, TEncoded, EOk>,
+  errEncoder: Encoder<EValue, EEncoded, EErr>,
+): Encoder<
+  Result<T, EValue>,
+  { readonly tag: 'ok'; readonly value: TEncoded } | {
+    readonly error: EEncoded;
+    readonly tag: 'err';
+  },
+  EOk | EErr
+> {
+  return fromEncode<
+    Result<T, EValue>,
+    { readonly tag: 'ok'; readonly value: TEncoded } | {
+      readonly error: EEncoded;
+      readonly tag: 'err';
+    },
+    EOk | EErr
+  >((value) => {
+    if (isOk(value)) {
+      const encoded = okEncoder.encode(value.value);
+      return isErr(encoded) ? encoded : ok({ tag: 'ok', value: encoded.value });
+    }
+
+    const encoded = errEncoder.encode(value.error);
+    return isErr(encoded) ? encoded : ok({ tag: 'err', error: encoded.value });
+  });
+}
+
+export function object<TShape extends ObjectShape>(
+  shape: TShape,
+): Encoder<
+  { readonly [K in keyof TShape]: EncoderInput<TShape[K]> },
+  { readonly [K in keyof TShape]: EncoderOutput<TShape[K]> },
+  EncoderError<TShape[keyof TShape]> | EncodeFailure
+> {
+  return fromEncode<
+    { readonly [K in keyof TShape]: EncoderInput<TShape[K]> },
+    { readonly [K in keyof TShape]: EncoderOutput<TShape[K]> },
+    EncoderError<TShape[keyof TShape]> | EncodeFailure
+  >((value) => {
+    if (!isPlainObject(value)) {
+      return err<EncoderError<TShape[keyof TShape]> | EncodeFailure>(
+        new EncodeFailure('Expected object.', value),
+      );
+    }
+
+    const record = value as Record<string, unknown>;
+    const encodedObject: Record<string, unknown> = {};
+
+    for (const key of Object.keys(shape)) {
+      const encoder = shape[key];
+      if (!encoder) {
+        continue;
+      }
+      const hasKey = key in record;
+      const rawValue = record[key];
+
+      if (!hasKey || rawValue === undefined) {
+        if (isOptionalEncoder(encoder)) {
+          encodedObject[key] = undefined;
+          continue;
+        }
+
+        return err<EncoderError<TShape[keyof TShape]> | EncodeFailure>(
+          new EncodeFailure(`Missing field "${key}".`, value),
+        );
+      }
+
+      const encoded = encoder.encode(rawValue as never) as Result<
+        unknown,
+        EncoderError<TShape[keyof TShape]> | EncodeFailure
+      >;
+      if (isErr(encoded)) {
+        return encoded;
+      }
+      encodedObject[key] = encoded.value;
+    }
+
+    return ok(encodedObject as { readonly [K in keyof TShape]: EncoderOutput<TShape[K]> });
+  });
+}
+
+function isOptionalEncoder(
+  value: Encoder<unknown, unknown, unknown>,
+): value is OptionalEncoder<unknown, unknown, unknown> {
+  return '__soundscriptOptional' in value && value.__soundscriptOptional === true;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/project-transform/src/stdlib/failures.d.ts

@@ -0,0 +1,23 @@
+export type ErrorFrame = {
+  readonly column: number;
+  readonly file: string;
+  readonly fn?: string;
+  readonly line: number;
+};
+
+export class Failure {
+  readonly cause?: unknown;
+  readonly message: string;
+  readonly name: string;
+  readonly trace: readonly ErrorFrame[];
+  constructor(
+    message?: string,
+    options?: {
+      cause?: unknown;
+      trace?: readonly ErrorFrame[];
+    },
+  );
+  withFrame(frame: ErrorFrame): this;
+}
+
+export function normalizeThrown(value: unknown): Error;

package/project-transform/src/stdlib/failures.js

@@ -0,0 +1,41 @@
+export class Failure {
+    constructor(message = '', options = {}) {
+        this.name = new.target.name;
+        this.message = message;
+        if ('cause' in options) {
+            this.cause = options.cause;
+        }
+        this.trace = options.trace ?? [];
+    }
+    withFrame(frame) {
+        const prototype = Object.getPrototypeOf(this);
+        const clone = (prototype === null ? Object.create(null) : Object.create(prototype));
+        Object.defineProperties(clone, Object.getOwnPropertyDescriptors(this));
+        Object.defineProperty(clone, 'trace', {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: [...this.trace, frame],
+        });
+        return clone;
+    }
+}
+export function normalizeThrown(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    const details = typeof value === 'object' && value !== null
+        ? value
+        : undefined;
+    const message = typeof details?.message === 'string'
+        ? details.message
+        : 'Non-Error thrown value.';
+    const error = new Error(message, { cause: value });
+    if (typeof details?.name === 'string') {
+        error.name = details.name;
+    }
+    if (typeof details?.stack === 'string') {
+        error.stack = details.stack;
+    }
+    return error;
+}

package/project-transform/src/stdlib/failures.ts

@@ -0,0 +1,64 @@
+export type ErrorFrame = {
+  readonly column: number;
+  readonly file: string;
+  readonly fn?: string;
+  readonly line: number;
+};
+
+export class Failure {
+  readonly cause?: unknown;
+  readonly message: string;
+  readonly name: string;
+  readonly trace: readonly ErrorFrame[];
+
+  constructor(
+    message = '',
+    options: {
+      cause?: unknown;
+      trace?: readonly ErrorFrame[];
+    } = {},
+  ) {
+    this.name = new.target.name;
+    this.message = message;
+    if ('cause' in options) {
+      this.cause = options.cause;
+    }
+    this.trace = options.trace ?? [];
+  }
+
+  withFrame(frame: ErrorFrame): this {
+    const prototype = Object.getPrototypeOf(this as object);
+    const clone = (prototype === null ? Object.create(null) : Object.create(prototype)) as this;
+    Object.defineProperties(clone, Object.getOwnPropertyDescriptors(this));
+    Object.defineProperty(clone, 'trace', {
+      configurable: true,
+      enumerable: true,
+      writable: false,
+      value: [...this.trace, frame],
+    });
+    return clone;
+  }
+}
+
+export function normalizeThrown(value: unknown): Error {
+  if (value instanceof Error) {
+    return value;
+  }
+
+  const details = typeof value === 'object' && value !== null
+    ? value as { message?: unknown; name?: unknown; stack?: unknown }
+    : undefined;
+  const message = typeof details?.message === 'string'
+    ? details.message
+    : 'Non-Error thrown value.';
+  const error = new Error(message, { cause: value });
+
+  if (typeof details?.name === 'string') {
+    error.name = details.name;
+  }
+  if (typeof details?.stack === 'string') {
+    error.stack = details.stack;
+  }
+
+  return error;
+}

package/project-transform/src/stdlib/fetch.d.ts

@@ -0,0 +1,67 @@
+import { URL, URLSearchParams } from 'sts:url';
+
+export interface AbortSignal {
+  readonly aborted: boolean;
+  readonly reason: unknown;
+  throwIfAborted(): void;
+}
+
+export type HeadersInit = Headers | Iterable<readonly [string, string]> | Record<string, string>;
+export type BodyInit = ArrayBuffer | string | Uint8Array<ArrayBufferLike> | URLSearchParams;
+export type RequestInfo = Request | string | URL;
+
+export interface RequestInit {
+  readonly body?: BodyInit | null;
+  readonly headers?: HeadersInit;
+  readonly method?: string;
+  readonly signal?: AbortSignal | null;
+}
+
+export interface ResponseInit {
+  readonly headers?: HeadersInit;
+  readonly status?: number;
+  readonly statusText?: string;
+}
+
+export declare class Headers {
+  constructor(init?: HeadersInit);
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  entries(): IterableIterator<[string, string]>;
+  get(name: string): string | null;
+  has(name: string): boolean;
+  keys(): IterableIterator<string>;
+  set(name: string, value: string): void;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+export declare class Request {
+  constructor(input: RequestInfo, init?: RequestInit);
+  readonly headers: Headers;
+  readonly method: string;
+  readonly signal: AbortSignal;
+  readonly url: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  clone(): Request;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+
+export declare class Response {
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  readonly headers: Headers;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  clone(): Response;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+  static error(): Response;
+  static json(data: unknown, init?: ResponseInit): Response;
+  static redirect(url: string | URL, status?: number): Response;
+}
+
+export declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;

package/project-transform/src/stdlib/fetch.js

@@ -0,0 +1,5 @@
+const fetchFn = fetch;
+const HeadersCtor = Headers;
+const RequestCtor = Request;
+const ResponseCtor = Response;
+export { fetchFn as fetch, HeadersCtor as Headers, RequestCtor as Request, ResponseCtor as Response, };

package/project-transform/src/stdlib/fetch.ts

@@ -0,0 +1,11 @@
+const fetchFn = fetch;
+const HeadersCtor = Headers;
+const RequestCtor = Request;
+const ResponseCtor = Response;
+
+export {
+  fetchFn as fetch,
+  HeadersCtor as Headers,
+  RequestCtor as Request,
+  ResponseCtor as Response,
+};

package/project-transform/src/stdlib/graphql.d.ts

@@ -0,0 +1,16 @@
+export interface GraphqlRawFragment {
+  readonly __graphqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface GraphqlQuery {
+  readonly query: string;
+  readonly values: readonly unknown[];
+}
+
+export interface GraphqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery;
+  raw(text: string): GraphqlRawFragment;
+}
+
+export const graphql: GraphqlTag;

package/project-transform/src/stdlib/graphql.js

@@ -0,0 +1,9 @@
+const graphqlTag = Object.assign((strings, ...values) => ({
+    query: String.raw({ raw: strings }, ...values.map(String)),
+    values: [...values],
+}), {
+    raw(text) {
+        return { __graphqlKind: 'raw', text };
+    },
+});
+export const graphql = graphqlTag;

package/project-transform/src/stdlib/graphql.ts

@@ -0,0 +1,28 @@
+export interface GraphqlRawFragment {
+  readonly __graphqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface GraphqlQuery {
+  readonly query: string;
+  readonly values: readonly unknown[];
+}
+
+export interface GraphqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery;
+  raw(text: string): GraphqlRawFragment;
+}
+
+const graphqlTag: GraphqlTag = Object.assign(
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery => ({
+    query: String.raw({ raw: strings }, ...values.map(String)),
+    values: [...values],
+  }),
+  {
+    raw(text: string): GraphqlRawFragment {
+      return { __graphqlKind: 'raw', text };
+    },
+  },
+);
+
+export const graphql = graphqlTag;

package/project-transform/src/stdlib/hash.d.ts

@@ -0,0 +1,34 @@
+import type { Eq } from 'sts:compare';
+import type { Option, Result } from 'sts:result';
+
+export type HashCode = number;
+
+export interface Hash<T> {
+  hash(value: T): HashCode;
+}
+
+export interface HashEq<T> extends Hash<T>, Eq<T> {}
+
+type HashEqValue<THashEq> = THashEq extends HashEq<infer TValue> ? TValue : never;
+
+export function fromHashEq<T>(
+  hash: (value: T) => HashCode,
+  equals: (left: T, right: T) => boolean,
+): HashEq<T>;
+export function contramap<A, B>(
+  hashEq: HashEq<A>,
+  project: (value: B) => A,
+): HashEq<B>;
+export function lazyHashEq<T>(getHashEq: () => HashEq<T>): HashEq<T>;
+export function arrayHash<T>(itemHash: HashEq<T>): HashEq<readonly T[]>;
+export function tupleHash<const THashEqs extends readonly HashEq<unknown>[]>(
+  ...elements: THashEqs
+): HashEq<{ readonly [K in keyof THashEqs]: HashEqValue<THashEqs[K]> }>;
+export function optionHash<T>(itemHash: HashEq<T>): HashEq<Option<T>>;
+export function resultHash<T, E>(okHash: HashEq<T>, errHash: HashEq<E>): HashEq<Result<T, E>>;
+
+export const stringHash: HashEq<string>;
+export const numberHash: HashEq<number>;
+export const booleanHash: HashEq<boolean>;
+export const bigintHash: HashEq<bigint>;
+export function combineHashes(...hashes: readonly HashCode[]): HashCode;

package/project-transform/src/stdlib/hash.js

@@ -0,0 +1,110 @@
+import { isErr, isNone, isOk, isSome } from '@soundscript/soundscript/result';
+export function fromHashEq(hash, equals) {
+    return {
+        hash(value) {
+            return normalizeHashCode(hash(value));
+        },
+        equals,
+    };
+}
+export function contramap(hashEq, project) {
+    return fromHashEq((value) => hashEq.hash(project(value)), (left, right) => hashEq.equals(project(left), project(right)));
+}
+export function lazyHashEq(getHashEq) {
+    return fromHashEq((value) => getHashEq().hash(value), (left, right) => getHashEq().equals(left, right));
+}
+export function arrayHash(itemHash) {
+    return fromHashEq((value) => combineHashes(...value.map((entry) => itemHash.hash(entry))), (left, right) => {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (!itemHash.equals(left[index], right[index])) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+export function tupleHash(...elements) {
+    return fromHashEq((value) => {
+        const values = value;
+        if (values.length !== elements.length) {
+            return 0;
+        }
+        return combineHashes(...elements.map((elementHash, index) => elementHash.hash(values[index])));
+    }, (left, right) => {
+        const leftValues = left;
+        const rightValues = right;
+        if (leftValues.length !== elements.length || rightValues.length !== elements.length) {
+            return false;
+        }
+        for (let index = 0; index < elements.length; index += 1) {
+            const elementHash = elements[index];
+            if (!elementHash) {
+                continue;
+            }
+            if (!elementHash.equals(leftValues[index], rightValues[index])) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+export function optionHash(itemHash) {
+    return fromHashEq((value) => isSome(value)
+        ? combineHashes(stringHash.hash('some'), itemHash.hash(value.value))
+        : stringHash.hash('none'), (left, right) => {
+        if (isSome(left) && isSome(right)) {
+            return itemHash.equals(left.value, right.value);
+        }
+        return isNone(left) && isNone(right);
+    });
+}
+export function resultHash(okHash, errHash) {
+    return fromHashEq((value) => isOk(value)
+        ? combineHashes(stringHash.hash('ok'), okHash.hash(value.value))
+        : combineHashes(stringHash.hash('err'), errHash.hash(value.error)), (left, right) => {
+        if (isOk(left) && isOk(right)) {
+            return okHash.equals(left.value, right.value);
+        }
+        if (isErr(left) && isErr(right)) {
+            return errHash.equals(left.error, right.error);
+        }
+        return false;
+    });
+}
+export const stringHash = fromHashEq(hashString, (left, right) => left === right);
+export const numberHash = fromHashEq((value) => hashString(normalizeNumberKey(value)), (left, right) => left === right || (Number.isNaN(left) && Number.isNaN(right)));
+export const booleanHash = fromHashEq((value) => value ? 1 : 0, (left, right) => left === right);
+export const bigintHash = fromHashEq((value) => hashString(value.toString()), (left, right) => left === right);
+export function combineHashes(...hashes) {
+    let hash = 0;
+    for (const value of hashes) {
+        hash = Math.imul(hash ^ normalizeHashCode(value), 0x01000193);
+    }
+    return normalizeHashCode(hash);
+}
+function normalizeHashCode(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return value | 0;
+}
+function normalizeNumberKey(value) {
+    if (Number.isNaN(value)) {
+        return 'NaN';
+    }
+    if (value === 0) {
+        return '0';
+    }
+    return String(value);
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash | 0;
+}