@soundscript/soundscript 0.1.12 → 0.1.15

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

@@ -0,0 +1,19 @@
+export type RandomBufferView =
+  | Int8Array<ArrayBufferLike>
+  | Uint8Array<ArrayBufferLike>
+  | Uint8ClampedArray<ArrayBufferLike>
+  | Int16Array<ArrayBufferLike>
+  | Uint16Array<ArrayBufferLike>
+  | Int32Array<ArrayBufferLike>
+  | Uint32Array<ArrayBufferLike>
+  | BigInt64Array<ArrayBufferLike>
+  | BigUint64Array<ArrayBufferLike>
+  | Float32Array<ArrayBufferLike>
+  | Float64Array<ArrayBufferLike>;
+
+export interface Crypto {
+  getRandomValues<T extends DataView<ArrayBufferLike> | RandomBufferView>(array: T): T;
+}
+
+export declare const crypto: Crypto;
+export declare const getRandomValues: Crypto['getRandomValues'];

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

@@ -0,0 +1,3 @@
+export const getRandomValues = crypto.getRandomValues.bind(crypto);
+const cryptoGlobal = crypto;
+export { cryptoGlobal as crypto };

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

@@ -0,0 +1,5 @@
+export const getRandomValues = crypto.getRandomValues.bind(crypto);
+
+const cryptoGlobal = crypto;
+
+export { cryptoGlobal as crypto };

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

@@ -0,0 +1,68 @@
+import type { Bind, Kind, Kind2, TypeLambda } from 'sts:hkt';
+import type { Applicative, Functor, Monad } from 'sts:typeclasses';
+
+// #[variance(T: out)]
+export class Ok<T> {
+  readonly tag: 'ok';
+  readonly value: T;
+  constructor(value: T);
+}
+// #[variance(E: out)]
+export class Err<E> {
+  readonly tag: 'err';
+  readonly error: E;
+  constructor(error: E);
+}
+
+// #[variance(T: out, E: out)]
+export type Result<T, E> = Ok<T> | Err<E>;
+// #[variance(T: out)]
+export class Some<T> {
+  readonly tag: 'some';
+  readonly value: T;
+  constructor(value: T);
+}
+export class None {
+  readonly tag: 'none';
+  constructor();
+}
+// #[variance(T: out)]
+export type Option<T> = Some<T> | None;
+
+export interface OptionF extends TypeLambda {
+  readonly type: Option<this['Args'][0]>;
+}
+
+export interface ResultF extends TypeLambda {
+  readonly type: Result<this['Args'][1], this['Args'][0]>;
+}
+
+export type OptionKind<T> = Kind<OptionF, T>;
+export type ResultKind<E, T> = Kind2<ResultF, E, T>;
+
+export function ok<T>(value: T): Result<T, never>;
+export function err(): Result<never, void>;
+export function err<E>(error: E): Result<never, E>;
+export function some<T>(value: T): Option<T>;
+export function none(): Option<never>;
+export function isOk<T, E>(value: Result<T, E>): value is Ok<T>;
+export function isErr<T, E>(value: Result<T, E>): value is Err<E>;
+export function isSome<T>(value: Option<T>): value is Some<T>;
+export function isNone<T>(value: Option<T>): value is None;
+export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export function resultOf<T, E>(
+  fn: () => Promise<T>,
+  mapError: (error: Error) => E,
+): Promise<Result<T, E>>;
+export function resultOf<T>(fn: () => T): Result<T, Error>;
+export function resultOf<T, E>(fn: () => T, mapError: (error: Error) => E): Result<T, E>;
+
+export const optionFunctor: Functor<OptionF>;
+export const optionApplicative: Applicative<OptionF>;
+export const optionMonad: Monad<OptionF>;
+export function resultFunctor<E>(): Functor<Bind<ResultF, [E]>>;
+export function resultApplicative<E>(): Applicative<Bind<ResultF, [E]>>;
+export function resultMonad<E>(): Monad<Bind<ResultF, [E]>>;
+
+export function Try<T, E>(value: Result<T, E>): T;
+export function Try<T>(value: Option<T>): T;

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

@@ -0,0 +1,139 @@
+import { normalizeThrown } from '@soundscript/soundscript/failures';
+import { __valueFactory, __valueKey, __valueReadonly, __valueShallowToken, } from '@soundscript/soundscript/value';
+const makeOk = __valueFactory((value) => __valueKey('ok', __valueShallowToken(value)), () => Object.create(Ok.prototype), (instance, value) => {
+    __valueReadonly(instance, 'tag', 'ok');
+    __valueReadonly(instance, 'value', value);
+});
+const makeErr = __valueFactory((error) => __valueKey('err', __valueShallowToken(error)), () => Object.create(Err.prototype), (instance, error) => {
+    __valueReadonly(instance, 'tag', 'err');
+    __valueReadonly(instance, 'error', error);
+});
+const makeSome = __valueFactory((value) => __valueKey('some', __valueShallowToken(value)), () => Object.create(Some.prototype), (instance, value) => {
+    __valueReadonly(instance, 'tag', 'some');
+    __valueReadonly(instance, 'value', value);
+});
+const makeNone = __valueFactory(() => __valueKey('none'), () => Object.create(None.prototype), (instance) => {
+    __valueReadonly(instance, 'tag', 'none');
+});
+// #[variance(T: out)]
+export class Ok {
+    constructor(value) {
+        return makeOk(value);
+    }
+}
+// #[variance(E: out)]
+export class Err {
+    constructor(error) {
+        return makeErr(error);
+    }
+}
+// #[variance(T: out)]
+export class Some {
+    constructor(value) {
+        return makeSome(value);
+    }
+}
+export class None {
+    constructor() {
+        return makeNone();
+    }
+}
+export function ok(value) {
+    return new Ok(value);
+}
+export function err(error) {
+    return new Err(error);
+}
+export function some(value) {
+    return new Some(value);
+}
+export function none() {
+    return new None();
+}
+export function isOk(value) {
+    return value instanceof Ok;
+}
+export function isErr(value) {
+    return value instanceof Err;
+}
+export function isSome(value) {
+    return value instanceof Some;
+}
+export function isNone(value) {
+    return value instanceof None;
+}
+function isPromiseInstance(value) {
+    return value instanceof Promise;
+}
+export function resultOf(fn, mapError) {
+    try {
+        const value = fn();
+        if (isPromiseInstance(value)) {
+            return value.then((resolved) => ok(resolved), (error) => {
+                const normalized = normalizeThrown(error);
+                return err(mapError ? mapError(normalized) : normalized);
+            });
+        }
+        return ok(value);
+    }
+    catch (error) {
+        const normalized = normalizeThrown(error);
+        return err(mapError ? mapError(normalized) : normalized);
+    }
+}
+function mapOption(value, f) {
+    return isSome(value) ? some(f(value.value)) : value;
+}
+function apOption(fn, value) {
+    if (!isSome(fn)) {
+        return fn;
+    }
+    return isSome(value) ? some(fn.value(value.value)) : value;
+}
+function flatMapOption(value, f) {
+    return isSome(value) ? f(value.value) : value;
+}
+const optionMonadImpl = {
+    ap: apOption,
+    flatMap: flatMapOption,
+    map: mapOption,
+    pure: some,
+};
+export const optionFunctor = optionMonadImpl;
+export const optionApplicative = optionMonadImpl;
+export const optionMonad = optionMonadImpl;
+function mapResult(value, f) {
+    return isOk(value) ? ok(f(value.value)) : value;
+}
+function apResult(fn, value) {
+    if (!isOk(fn)) {
+        return fn;
+    }
+    return isOk(value) ? ok(fn.value(value.value)) : value;
+}
+function flatMapResult(value, f) {
+    return isOk(value) ? f(value.value) : value;
+}
+function createResultMonad() {
+    return {
+        ap: apResult,
+        flatMap: flatMapResult,
+        map: mapResult,
+        pure: ok,
+    };
+}
+export function resultFunctor() {
+    return createResultMonad();
+}
+export function resultApplicative() {
+    return createResultMonad();
+}
+export function resultMonad() {
+    return createResultMonad();
+}
+function macroRuntimeError(name) {
+    throw new Error(`${name}(...) is a soundscript macro and should be removed during soundscript expansion.`);
+}
+export function Try(_value) {
+    return macroRuntimeError('Try');
+}

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

@@ -0,0 +1,248 @@
+import { normalizeThrown } from 'sts:failures';
+import { type Bind, type Kind, type Kind2, type TypeLambda } from 'sts:hkt';
+import { type Applicative, type Functor, type Monad } from 'sts:typeclasses';
+import {
+  __valueFactory,
+  __valueKey,
+  __valueReadonly,
+  __valueShallowToken,
+} from 'sts:value';
+
+const makeOk = __valueFactory<Ok<unknown>, [unknown]>(
+  (value) => __valueKey('ok', __valueShallowToken(value)),
+  () => Object.create(Ok.prototype) as Ok<unknown>,
+  (instance, value) => {
+    __valueReadonly(instance, 'tag', 'ok');
+    __valueReadonly(instance, 'value', value);
+  },
+);
+
+const makeErr = __valueFactory<Err<unknown>, [unknown]>(
+  (error) => __valueKey('err', __valueShallowToken(error)),
+  () => Object.create(Err.prototype) as Err<unknown>,
+  (instance, error) => {
+    __valueReadonly(instance, 'tag', 'err');
+    __valueReadonly(instance, 'error', error);
+  },
+);
+
+const makeSome = __valueFactory<Some<unknown>, [unknown]>(
+  (value) => __valueKey('some', __valueShallowToken(value)),
+  () => Object.create(Some.prototype) as Some<unknown>,
+  (instance, value) => {
+    __valueReadonly(instance, 'tag', 'some');
+    __valueReadonly(instance, 'value', value);
+  },
+);
+
+const makeNone = __valueFactory<None, []>(
+  () => __valueKey('none'),
+  () => Object.create(None.prototype) as None,
+  (instance) => {
+    __valueReadonly(instance, 'tag', 'none');
+  },
+);
+
+// #[variance(T: out)]
+export class Ok<T> {
+  readonly tag!: 'ok';
+  readonly value!: T;
+
+  constructor(value: T) {
+    return makeOk(value) as Ok<T>;
+  }
+}
+
+// #[variance(E: out)]
+export class Err<E> {
+  readonly tag!: 'err';
+  readonly error!: E;
+
+  constructor(error: E) {
+    return makeErr(error) as Err<E>;
+  }
+}
+
+// #[variance(T: out, E: out)]
+export type Result<T, E> = Ok<T> | Err<E>;
+
+// #[variance(T: out)]
+export class Some<T> {
+  readonly tag!: 'some';
+  readonly value!: T;
+
+  constructor(value: T) {
+    return makeSome(value) as Some<T>;
+  }
+}
+
+export class None {
+  readonly tag!: 'none';
+
+  constructor() {
+    return makeNone();
+  }
+}
+
+// #[variance(T: out)]
+export type Option<T> = Some<T> | None;
+
+export interface OptionF extends TypeLambda {
+  readonly type: Option<this['Args'][0]>;
+}
+
+export interface ResultF extends TypeLambda {
+  readonly type: Result<this['Args'][1], this['Args'][0]>;
+}
+
+export type OptionKind<T> = Kind<OptionF, T>;
+export type ResultKind<E, T> = Kind2<ResultF, E, T>;
+
+export function ok<T>(value: T): Result<T, never> {
+  return new Ok(value);
+}
+
+export function err(): Result<never, void>;
+export function err<E>(error: E): Result<never, E>;
+export function err<E>(error?: E): Result<never, E | void> {
+  return new Err(error);
+}
+
+export function some<T>(value: T): Option<T> {
+  return new Some(value);
+}
+
+export function none(): Option<never> {
+  return new None();
+}
+
+export function isOk<T, E>(value: Result<T, E>): value is Ok<T> {
+  return value instanceof Ok;
+}
+
+export function isErr<T, E>(value: Result<T, E>): value is Err<E> {
+  return value instanceof Err;
+}
+
+export function isSome<T>(value: Option<T>): value is Some<T> {
+  return value instanceof Some;
+}
+
+export function isNone<T>(value: Option<T>): value is None {
+  return value instanceof None;
+}
+
+function isPromiseInstance<T>(value: unknown): value is Promise<T> {
+  return value instanceof Promise;
+}
+
+export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export function resultOf<T, E>(
+  fn: () => Promise<T>,
+  mapError: (error: Error) => E,
+): Promise<Result<T, E>>;
+export function resultOf<T>(fn: () => T): Result<T, Error>;
+export function resultOf<T, E>(fn: () => T, mapError: (error: Error) => E): Result<T, E>;
+export function resultOf<T, E>(
+  fn: () => T | Promise<T>,
+  mapError?: (error: Error) => E,
+): Result<T, E | Error> | Promise<Result<T, E | Error>> {
+  try {
+    const value = fn();
+    if (isPromiseInstance<T>(value)) {
+      return value.then(
+        (resolved) => ok(resolved),
+        (error) => {
+          const normalized = normalizeThrown(error);
+          return err(mapError ? mapError(normalized) : normalized);
+        },
+      );
+    }
+    return ok(value);
+  } catch (error) {
+    const normalized = normalizeThrown(error);
+    return err(mapError ? mapError(normalized) : normalized);
+  }
+}
+
+function mapOption<A, B>(value: Option<A>, f: (value: A) => B): Option<B> {
+  return isSome(value) ? some(f(value.value)) : value;
+}
+
+function apOption<A, B>(
+  fn: Option<(value: A) => B>,
+  value: Option<A>,
+): Option<B> {
+  if (!isSome(fn)) {
+    return fn;
+  }
+  return isSome(value) ? some(fn.value(value.value)) : value;
+}
+
+function flatMapOption<A, B>(value: Option<A>, f: (value: A) => Option<B>): Option<B> {
+  return isSome(value) ? f(value.value) : value;
+}
+
+const optionMonadImpl: Monad<OptionF> = {
+  ap: apOption,
+  flatMap: flatMapOption,
+  map: mapOption,
+  pure: some,
+};
+
+export const optionFunctor: Functor<OptionF> = optionMonadImpl;
+export const optionApplicative: Applicative<OptionF> = optionMonadImpl;
+export const optionMonad: Monad<OptionF> = optionMonadImpl;
+
+function mapResult<E, A, B>(value: Result<A, E>, f: (value: A) => B): Result<B, E> {
+  return isOk(value) ? ok(f(value.value)) : value;
+}
+
+function apResult<E, A, B>(
+  fn: Result<(value: A) => B, E>,
+  value: Result<A, E>,
+): Result<B, E> {
+  if (!isOk(fn)) {
+    return fn;
+  }
+  return isOk(value) ? ok(fn.value(value.value)) : value;
+}
+
+function flatMapResult<E, A, B>(
+  value: Result<A, E>,
+  f: (value: A) => Result<B, E>,
+): Result<B, E> {
+  return isOk(value) ? f(value.value) : value;
+}
+
+function createResultMonad<E>(): Monad<Bind<ResultF, [E]>> {
+  return {
+    ap: apResult,
+    flatMap: flatMapResult,
+    map: mapResult,
+    pure: ok,
+  };
+}
+
+export function resultFunctor<E>(): Functor<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+export function resultApplicative<E>(): Applicative<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+export function resultMonad<E>(): Monad<Bind<ResultF, [E]>> {
+  return createResultMonad<E>();
+}
+
+function macroRuntimeError(name: string): never {
+  throw new Error(
+    `${name}(...) is a soundscript macro and should be removed during soundscript expansion.`,
+  );
+}
+
+export function Try<T, E>(value: Result<T, E>): T;
+export function Try(_value: unknown): never {
+  return macroRuntimeError('Try');
+}

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

@@ -0,0 +1,22 @@
+export interface SqlQuery {
+  readonly text: string;
+  readonly params: readonly unknown[];
+}
+
+export interface SqlIdentifier {
+  readonly __sqlKind: 'identifier';
+  readonly name: string;
+}
+
+export interface SqlRawFragment {
+  readonly __sqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface SqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): SqlQuery;
+  ident(name: string): SqlIdentifier;
+  raw(text: string): SqlRawFragment;
+}
+
+export const sql: SqlTag;

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

@@ -0,0 +1,23 @@
+function buildSqlQuery(strings, values) {
+    let text = '';
+    for (let index = 0; index < strings.length; index += 1) {
+        text += strings[index] ?? '';
+        if (index < values.length) {
+            text += `$${index + 1}`;
+        }
+    }
+    return {
+        text,
+        params: [...values],
+    };
+}
+const sqlTag = ((strings, ...values) => buildSqlQuery(strings, values));
+sqlTag.ident = (name) => ({
+    __sqlKind: 'identifier',
+    name,
+});
+sqlTag.raw = (text) => ({
+    __sqlKind: 'raw',
+    text,
+});
+export const sql = sqlTag;

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

@@ -0,0 +1,53 @@
+export interface SqlQuery {
+  readonly text: string;
+  readonly params: readonly unknown[];
+}
+
+export interface SqlIdentifier {
+  readonly __sqlKind: 'identifier';
+  readonly name: string;
+}
+
+export interface SqlRawFragment {
+  readonly __sqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface SqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): SqlQuery;
+  ident(name: string): SqlIdentifier;
+  raw(text: string): SqlRawFragment;
+}
+
+function buildSqlQuery(
+  strings: TemplateStringsArray,
+  values: readonly unknown[],
+): SqlQuery {
+  let text = '';
+  for (let index = 0; index < strings.length; index += 1) {
+    text += strings[index] ?? '';
+    if (index < values.length) {
+      text += `$${index + 1}`;
+    }
+  }
+
+  return {
+    text,
+    params: [...values],
+  };
+}
+
+const sqlTag = ((strings: TemplateStringsArray, ...values: readonly unknown[]) =>
+  buildSqlQuery(strings, values)) as SqlTag;
+
+sqlTag.ident = (name: string): SqlIdentifier => ({
+  __sqlKind: 'identifier',
+  name,
+});
+
+sqlTag.raw = (text: string): SqlRawFragment => ({
+  __sqlKind: 'raw',
+  text,
+});
+
+export const sql = sqlTag;

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

@@ -0,0 +1,24 @@
+export interface TextDecodeOptions {
+  stream?: boolean;
+}
+
+export interface TextDecoderOptions {
+  fatal?: boolean;
+  ignoreBOM?: boolean;
+}
+
+export declare class TextEncoder {
+  constructor();
+  encode(input?: string): Uint8Array<ArrayBufferLike>;
+}
+
+export declare class TextDecoder {
+  constructor(label?: string, options?: TextDecoderOptions);
+  decode(
+    input?: ArrayBuffer | DataView<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null,
+    options?: TextDecodeOptions,
+  ): string;
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+}

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

@@ -0,0 +1,3 @@
+const TextDecoderCtor = TextDecoder;
+const TextEncoderCtor = TextEncoder;
+export { TextDecoderCtor as TextDecoder, TextEncoderCtor as TextEncoder };

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

@@ -0,0 +1,4 @@
+const TextDecoderCtor = TextDecoder;
+const TextEncoderCtor = TextEncoder;
+
+export { TextDecoderCtor as TextDecoder, TextEncoderCtor as TextEncoder };

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

@@ -0,0 +1,2 @@
+export function lazy<T>(value: T): () => T;
+export function memo<T>(value: T): () => T;

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

@@ -0,0 +1,9 @@
+function macroRuntimeError(name) {
+    throw new Error(`${name}(...) is a soundscript macro and should be removed during soundscript expansion.`);
+}
+export function lazy(_value) {
+    return macroRuntimeError('lazy');
+}
+export function memo(_value) {
+    return macroRuntimeError('memo');
+}

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

@@ -0,0 +1,15 @@
+function macroRuntimeError(name: string): never {
+  throw new Error(
+    `${name}(...) is a soundscript macro and should be removed during soundscript expansion.`,
+  );
+}
+
+export function lazy<T>(_value: T): () => T;
+export function lazy(_value: unknown): never {
+  return macroRuntimeError('lazy');
+}
+
+export function memo<T>(_value: T): () => T;
+export function memo(_value: unknown): never {
+  return macroRuntimeError('memo');
+}