@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,151 @@
+import { isErr, isNone, isOk, isSome, type Option, type Result } from 'sts:result';
+
+export type Ordering = -1 | 0 | 1;
+
+export interface Eq<T> {
+  equals(left: T, right: T): boolean;
+}
+
+export interface Order<T> extends Eq<T> {
+  compare(left: T, right: T): Ordering;
+}
+
+type EqValue<TEq> = TEq extends Eq<infer TValue> ? TValue : never;
+
+export const stringEq: Eq<string> = {
+  equals(left, right) {
+    return left === right;
+  },
+};
+
+export const numberEq: Eq<number> = {
+  equals(left, right) {
+    return left === right || (Number.isNaN(left) && Number.isNaN(right));
+  },
+};
+
+export const booleanEq: Eq<boolean> = {
+  equals(left, right) {
+    return left === right;
+  },
+};
+
+export const bigintEq: Eq<bigint> = {
+  equals(left, right) {
+    return left === right;
+  },
+};
+
+export function lazyEq<T>(getEq: () => Eq<T>): Eq<T> {
+  return {
+    equals(left, right) {
+      return getEq().equals(left, right);
+    },
+  };
+}
+
+export function arrayEq<T>(itemEq: Eq<T>): Eq<readonly T[]> {
+  return {
+    equals(left, right) {
+      if (left.length !== right.length) {
+        return false;
+      }
+
+      for (let index = 0; index < left.length; index += 1) {
+        if (!itemEq.equals(left[index]!, right[index]!)) {
+          return false;
+        }
+      }
+
+      return true;
+    },
+  };
+}
+
+export function tupleEq<const TEqs extends readonly Eq<unknown>[]>(
+  ...elements: TEqs
+): Eq<{ readonly [K in keyof TEqs]: EqValue<TEqs[K]> }> {
+  return {
+    equals(left, right) {
+      const leftValues = left as readonly unknown[];
+      const rightValues = right as readonly unknown[];
+      if (leftValues.length !== elements.length || rightValues.length !== elements.length) {
+        return false;
+      }
+
+      for (let index = 0; index < elements.length; index += 1) {
+        const elementEq = elements[index];
+        if (!elementEq) {
+          continue;
+        }
+        if (!elementEq.equals(leftValues[index], rightValues[index])) {
+          return false;
+        }
+      }
+
+      return true;
+    },
+  };
+}
+
+export function optionEq<T>(itemEq: Eq<T>): Eq<Option<T>> {
+  return {
+    equals(left, right) {
+      if (isSome(left) && isSome(right)) {
+        return itemEq.equals(left.value, right.value);
+      }
+
+      return isNone(left) && isNone(right);
+    },
+  };
+}
+
+export function resultEq<T, E>(okEq: Eq<T>, errEq: Eq<E>): Eq<Result<T, E>> {
+  return {
+    equals(left, right) {
+      if (isOk(left) && isOk(right)) {
+        return okEq.equals(left.value, right.value);
+      }
+
+      if (isErr(left) && isErr(right)) {
+        return errEq.equals(left.error, right.error);
+      }
+
+      return false;
+    },
+  };
+}
+
+export function fromCompare<T>(compare: (left: T, right: T) => number): Order<T> {
+  return {
+    equals(left, right) {
+      return normalizeOrdering(compare(left, right)) === 0;
+    },
+    compare(left, right) {
+      return normalizeOrdering(compare(left, right));
+    },
+  };
+}
+
+export function reverse<T>(order: Order<T>): Order<T> {
+  return fromCompare((left, right) => order.compare(right, left));
+}
+
+export function thenBy<T>(primary: Order<T>, secondary: Order<T>): Order<T> {
+  return fromCompare((left, right) => {
+    const primaryOrdering = primary.compare(left, right);
+    return primaryOrdering !== 0 ? primaryOrdering : secondary.compare(left, right);
+  });
+}
+
+function normalizeOrdering(value: number): Ordering {
+  if (value < 0) {
+    return -1;
+  }
+
+  if (value > 0) {
+    return 1;
+  }
+
+  return 0;
+}

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

@@ -0,0 +1,16 @@
+export interface CssRawFragment {
+  readonly __cssKind: 'raw';
+  readonly text: string;
+}
+
+export interface CssTemplate {
+  readonly text: string;
+  readonly values: readonly unknown[];
+}
+
+export interface CssTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate;
+  raw(text: string): CssRawFragment;
+}
+
+export const css: CssTag;

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

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

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

@@ -0,0 +1,28 @@
+export interface CssRawFragment {
+  readonly __cssKind: 'raw';
+  readonly text: string;
+}
+
+export interface CssTemplate {
+  readonly text: string;
+  readonly values: readonly unknown[];
+}
+
+export interface CssTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate;
+  raw(text: string): CssRawFragment;
+}
+
+const cssTag: CssTag = Object.assign(
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate => ({
+    text: String.raw({ raw: strings }, ...values.map(String)),
+    values: [...values],
+  }),
+  {
+    raw(text: string): CssRawFragment {
+      return { __cssKind: 'raw', text };
+    },
+  },
+);
+
+export const css = cssTag;

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

@@ -0,0 +1,2 @@
+export function assert(condition: unknown, message?: string): asserts condition;
+export function log<T>(value: T): T;

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

@@ -0,0 +1,9 @@
+export function assert(condition, message = 'Assertion failed.') {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+export function log(value) {
+    console.log(value);
+    return value;
+}

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

@@ -0,0 +1,10 @@
+export function assert(condition: unknown, message = 'Assertion failed.'): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+export function log<T>(value: T): T {
+  console.log(value);
+  return value;
+}

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

@@ -0,0 +1,86 @@
+import { type ErrorFrame, Failure } from 'sts:failures';
+import type { Option, Result } from 'sts:result';
+
+export type DecodePathSegment = string | number;
+export type DecodePath = readonly DecodePathSegment[];
+
+export class DecodeFailure extends Failure {
+  readonly path: DecodePath;
+  constructor(
+    message?: string,
+    options?: {
+      cause?: unknown;
+      path?: DecodePath;
+      trace?: readonly ErrorFrame[];
+    },
+  );
+  at(segment: DecodePathSegment): this;
+}
+
+// #[variance(T: out, E: out)]
+export type Decoder<T, E = DecodeFailure> = {
+  decode(value: unknown): Result<T, E>;
+};
+
+// #[variance(T: out, E: out)]
+export type OptionalDecoder<T, E = DecodeFailure> = Decoder<T | undefined, E> & {
+  readonly __soundscriptOptional: true;
+  readonly inner: Decoder<T, E>;
+};
+
+type DecoderValue<TDecoder> = TDecoder extends Decoder<infer TValue, unknown> ? TValue : never;
+type DecoderError<TDecoder> = TDecoder extends Decoder<unknown, infer E> ? E : never;
+type ObjectShape = Record<string, Decoder<unknown, unknown>>;
+type TupleShape = readonly Decoder<unknown, unknown>[];
+
+export const string: Decoder<string>;
+export const number: Decoder<number>;
+export const boolean: Decoder<boolean>;
+export const bigint: Decoder<bigint>;
+export function lazy<T, E>(getDecoder: () => Decoder<T, E>): Decoder<T, E>;
+
+export function optional<T, E>(decoder: Decoder<T, E>): OptionalDecoder<T, E>;
+export function literal<const T extends string | number | boolean | null>(value: T): Decoder<T>;
+export function array<T, E>(item: Decoder<T, E>): Decoder<readonly T[], E | DecodeFailure>;
+export function tuple<const TElements extends TupleShape>(
+  ...elements: TElements
+): Decoder<
+  { readonly [K in keyof TElements]: DecoderValue<TElements[K]> },
+  DecoderError<TElements[number]> | DecodeFailure
+>;
+export function option<T, E>(item: Decoder<T, E>): Decoder<Option<T>, E | DecodeFailure>;
+export function result<T, EValue, EDecodeValue, EDecodeError>(
+  okDecoder: Decoder<T, EDecodeValue>,
+  errDecoder: Decoder<EValue, EDecodeError>,
+): Decoder<Result<T, EValue>, EDecodeValue | EDecodeError | DecodeFailure>;
+export function object<TShape extends ObjectShape>(
+  shape: TShape,
+): Decoder<
+  { readonly [K in keyof TShape]: DecoderValue<TShape[K]> },
+  DecoderError<TShape[keyof TShape]> | DecodeFailure
+>;
+export function field<K extends string, T, E>(
+  key: K,
+  decoder: Decoder<T, E>,
+): Decoder<T, E | DecodeFailure>;
+export function optionalField<K extends string, T, E>(
+  key: K,
+  decoder: Decoder<T, E>,
+): Decoder<T | undefined, E | DecodeFailure>;
+export function union<A, B, ELeft, ERight>(
+  left: Decoder<A, ELeft>,
+  right: Decoder<B, ERight>,
+): Decoder<A | B, ELeft | ERight | DecodeFailure>;
+export function map<A, B, E>(
+  decoder: Decoder<A, E>,
+  project: (value: A) => B,
+): Decoder<B, E>;
+export function andThen<A, B, E>(
+  decoder: Decoder<A, E>,
+  project: (value: A) => Decoder<B, E>,
+): Decoder<B, E>;
+export function refine<A, B extends A, E>(
+  decoder: Decoder<A, E>,
+  predicate: (value: A) => value is B,
+  message: string,
+): Decoder<B, E | DecodeFailure>;

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

@@ -0,0 +1,254 @@
+import { Failure } from '@soundscript/soundscript/failures';
+import { err, isErr, none, ok, some } from '@soundscript/soundscript/result';
+export class DecodeFailure extends Failure {
+    constructor(message = 'Failed to decode value.', options = {}) {
+        super(message, {
+            ...(options.cause === undefined ? {} : { cause: options.cause }),
+            ...(options.trace === undefined ? {} : { trace: options.trace }),
+        });
+        this.path = options.path ?? [];
+    }
+    at(segment) {
+        const prototype = Object.getPrototypeOf(this);
+        const clone = (prototype === null ? Object.create(null) : Object.create(prototype));
+        Object.defineProperties(clone, Object.getOwnPropertyDescriptors(this));
+        Object.defineProperty(clone, 'path', {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: [segment, ...this.path],
+        });
+        return clone;
+    }
+}
+export const string = {
+    decode(value) {
+        return typeof value === 'string'
+            ? ok(value)
+            : err(new DecodeFailure('Expected string.', { cause: value }));
+    },
+};
+export const number = {
+    decode(value) {
+        return typeof value === 'number'
+            ? ok(value)
+            : err(new DecodeFailure('Expected number.', { cause: value }));
+    },
+};
+export const boolean = {
+    decode(value) {
+        return typeof value === 'boolean'
+            ? ok(value)
+            : err(new DecodeFailure('Expected boolean.', { cause: value }));
+    },
+};
+export const bigint = {
+    decode(value) {
+        if (typeof value === 'bigint') {
+            return ok(value);
+        }
+        if (typeof value === 'number') {
+            return Number.isInteger(value) && Number.isSafeInteger(value)
+                ? ok(BigInt(value))
+                : err(new DecodeFailure('Expected bigint.', { cause: value }));
+        }
+        if (typeof value === 'string') {
+            try {
+                return ok(BigInt(value));
+            }
+            catch {
+                return err(new DecodeFailure('Expected bigint.', { cause: value }));
+            }
+        }
+        return err(new DecodeFailure('Expected bigint.', { cause: value }));
+    },
+};
+export function lazy(getDecoder) {
+    return {
+        decode(value) {
+            return getDecoder().decode(value);
+        },
+    };
+}
+export function optional(decoder) {
+    return {
+        __soundscriptOptional: true,
+        inner: decoder,
+        decode(value) {
+            return value === undefined ? ok(undefined) : decoder.decode(value);
+        },
+    };
+}
+export function literal(value) {
+    return {
+        decode(input) {
+            return Object.is(input, value)
+                ? ok(value)
+                : err(new DecodeFailure(`Expected literal ${JSON.stringify(value)}.`, { cause: input }));
+        },
+    };
+}
+export function array(item) {
+    return {
+        decode(value) {
+            if (!Array.isArray(value)) {
+                return err(new DecodeFailure('Expected array.', { cause: value }));
+            }
+            const decodedValues = [];
+            for (let index = 0; index < value.length; index += 1) {
+                const decoded = item.decode(value[index]);
+                if (isErr(decoded)) {
+                    return err(prependPathIfPossible(decoded.error, index));
+                }
+                decodedValues.push(decoded.value);
+            }
+            return ok(decodedValues);
+        },
+    };
+}
+export function tuple(...elements) {
+    return {
+        decode(value) {
+            if (!Array.isArray(value)) {
+                return err(new DecodeFailure('Expected tuple.', { cause: value }));
+            }
+            if (value.length !== elements.length) {
+                return err(new DecodeFailure(`Expected tuple of length ${elements.length}.`, {
+                    cause: value,
+                }));
+            }
+            const decodedValues = [];
+            for (let index = 0; index < elements.length; index += 1) {
+                const elementDecoder = elements[index];
+                if (!elementDecoder) {
+                    continue;
+                }
+                const decoded = elementDecoder.decode(value[index]);
+                if (isErr(decoded)) {
+                    return err(prependPathIfPossible(decoded.error, index));
+                }
+                decodedValues.push(decoded.value);
+            }
+            return ok(decodedValues);
+        },
+    };
+}
+export function option(item) {
+    return union(map(object({
+        tag: literal('some'),
+        value: item,
+    }), (value) => some(value.value)), map(object({
+        tag: literal('none'),
+    }), () => none()));
+}
+export function result(okDecoder, errDecoder) {
+    return union(map(object({
+        tag: literal('ok'),
+        value: okDecoder,
+    }), (value) => ok(value.value)), map(object({
+        tag: literal('err'),
+        error: errDecoder,
+    }), (value) => err(value.error)));
+}
+export function object(shape) {
+    return {
+        decode(value) {
+            if (!isPlainObject(value)) {
+                return err(new DecodeFailure('Expected object.', { cause: value }));
+            }
+            const record = value;
+            const decodedObject = {};
+            for (const key of Object.keys(shape)) {
+                const decoder = shape[key];
+                if (!decoder) {
+                    continue;
+                }
+                const hasKey = key in record;
+                const rawValue = record[key];
+                if (!hasKey || rawValue === undefined) {
+                    if (isOptionalDecoder(decoder)) {
+                        decodedObject[key] = undefined;
+                        continue;
+                    }
+                    return err(new DecodeFailure(`Missing field "${key}".`, {
+                        cause: value,
+                        path: [key],
+                    }));
+                }
+                const decoded = decoder.decode(rawValue);
+                if (isErr(decoded)) {
+                    return err(prependPathIfPossible(decoded.error, key));
+                }
+                decodedObject[key] = decoded.value;
+            }
+            return ok(decodedObject);
+        },
+    };
+}
+export function field(key, decoder) {
+    const shape = { [key]: decoder };
+    return map(object(shape), (value) => value[key]);
+}
+export function optionalField(key, decoder) {
+    const shape = { [key]: optional(decoder) };
+    return map(object(shape), (value) => value[key]);
+}
+export function union(left, right) {
+    return {
+        decode(value) {
+            const leftDecoded = left.decode(value);
+            if (isErr(leftDecoded)) {
+                const rightDecoded = right.decode(value);
+                if (isErr(rightDecoded)) {
+                    return err(new DecodeFailure('Expected one of the union members.', {
+                        cause: value,
+                    }));
+                }
+                return rightDecoded;
+            }
+            return leftDecoded;
+        },
+    };
+}
+export function map(decoder, project) {
+    return {
+        decode(value) {
+            const decoded = decoder.decode(value);
+            return isErr(decoded) ? decoded : ok(project(decoded.value));
+        },
+    };
+}
+export function andThen(decoder, project) {
+    return {
+        decode(value) {
+            const decoded = decoder.decode(value);
+            return isErr(decoded) ? decoded : project(decoded.value).decode(valueOf(decoded));
+        },
+    };
+}
+export function refine(decoder, predicate, message) {
+    return {
+        decode(value) {
+            const decoded = decoder.decode(value);
+            if (isErr(decoded)) {
+                return decoded;
+            }
+            return predicate(decoded.value)
+                ? ok(decoded.value)
+                : err(new DecodeFailure(message, { cause: value }));
+        },
+    };
+}
+function prependPathIfPossible(error, segment) {
+    return error instanceof DecodeFailure ? error.at(segment) : error;
+}
+function isOptionalDecoder(value) {
+    return '__soundscriptOptional' in value &&
+        value.__soundscriptOptional === true;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function valueOf(decoded) {
+    return decoded.value;
+}