@valbuild/core 0.25.0 → 0.27.0

package/src/fp/result.ts

@@ -1,214 +0,0 @@
-import { isNonEmpty, NonEmptyArray } from "./array";
-
-export type Ok<T> = {
-  readonly kind: "ok";
-  readonly value: T;
-};
-export type Err<E> = {
-  readonly kind: "err";
-  readonly error: E;
-};
-
-export type Result<T, E> = Ok<T> | Err<E>;
-
-/**
- * Singleton instance of Ok<void>. Used to optimize results whose Ok values are
- * void.
- */
-export const voidOk: Ok<void> = Object.freeze({
-  kind: "ok",
-  value: undefined,
-});
-
-export function ok<T>(value: T): Ok<T> {
-  if (value === undefined) return voidOk as Ok<T>;
-  return {
-    kind: "ok",
-    value,
-  };
-}
-
-export function err<E>(error: E): Err<E> {
-  return {
-    kind: "err",
-    error,
-  };
-}
-
-export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
-  return result === voidOk || result.kind === "ok";
-}
-
-export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
-  return result !== voidOk && result.kind === "err";
-}
-
-export type OkType<R> = R extends Result<infer T, unknown> ? T : never;
-export type ErrType<R> = R extends Result<unknown, infer E> ? E : never;
-
-/**
- * If all results are Ok (or if results is empty), returns Ok with all the Ok
- * values concatenated into an array. If any result is Err, returns Err with all
- * Err values concatenated into an array.
- *
- * @see {@link all} for use with simple array types.
- */
-export function allT<T extends unknown[], E>(results: {
-  readonly [P in keyof T]: Result<T[P], E>;
-}): Result<T, NonEmptyArray<E>> {
-  const values: T[number][] = [];
-  const errors: E[] = [];
-  for (const result of results) {
-    if (isOk(result)) {
-      values.push(result.value);
-    } else {
-      errors.push(result.error);
-    }
-  }
-  if (isNonEmpty(errors)) {
-    return err(errors);
-  } else {
-    return ok(values as T);
-  }
-}
-
-/**
- * If all results are Ok (or if results is empty), returns Ok with all the Ok
- * values concatenated into an array. If any result is Err, returns Err with all
- * Err values concatenated into an array.
- *
- * @see {@link allT} for use with tuple types.
- */
-export function all<T, E>(
-  results: readonly Result<T, E>[]
-): Result<T[], NonEmptyArray<E>> {
-  return allT<T[], E>(results);
-}
-
-/**
- * If all results are Ok (or if results is empty), returns Ok. If any result is
- * Err, returns Err with all Err values concatenated into an array.
- */
-export function allV<E>(
-  results: readonly Result<unknown, E>[]
-): Result<void, NonEmptyArray<E>> {
-  const errs: E[] = [];
-  for (const result of results) {
-    if (isErr(result)) {
-      errs.push(result.error);
-    }
-  }
-  if (isNonEmpty(errs)) {
-    return err(errs);
-  }
-  return voidOk;
-}
-
-/**
- * Perform a reduction over an array with a Result-returning reducer. If the
- * reducer returns Ok, its value is used as the next value. If the reducer
- * returns Err, it is returned immediately.
- *
- * flatMapReduce is a short-circuiting equivalent to:
- * ```
- * arr.reduce(
- *   (accRes, current, currentIndex) =>
- *     flatMap((acc) => reducer(acc, current, currentIndex))(accRes),
- *   ok(initVal)
- * )
- * ```
- */
-export function flatMapReduce<T, E, A>(
-  reducer: (acc: T, current: A, currentIndex: number) => Result<T, E>,
-  initVal: T
-): (arr: readonly A[]) => Result<T, E> {
-  return (arr) => {
-    let val: Result<T, E> = ok(initVal);
-    for (let i = 0; i < arr.length && isOk(val); ++i) {
-      val = reducer(val.value, arr[i], i);
-    }
-    return val;
-  };
-}
-
-export function map<T0, T1>(
-  onOk: (value: T0) => T1
-): <E>(result: Result<T0, E>) => Result<T1, E> {
-  return (result) => {
-    if (isOk(result)) {
-      return ok(onOk(result.value));
-    } else {
-      return result;
-    }
-  };
-}
-
-export function flatMap<T0, T1, E1>(
-  onOk: (value: T0) => Result<T1, E1>
-): <E>(result: Result<T0, E>) => Result<T1, E | E1> {
-  return (result) => {
-    if (isOk(result)) {
-      return onOk(result.value);
-    } else {
-      return result;
-    }
-  };
-}
-
-export function mapErr<E0, E1>(
-  onErr: (error: E0) => E1
-): <T>(result: Result<T, E0>) => Result<T, E1> {
-  return (result) => {
-    if (isErr(result)) {
-      return err(onErr(result.error));
-    } else {
-      return result;
-    }
-  };
-}
-
-export function fromPredicate<T0, T1 extends T0, E>(
-  refinement: (value: T0) => value is T1,
-  onFalse: (value: T0) => E
-): (value: T0) => Result<T1, E>;
-export function fromPredicate<T0, E>(
-  refinement: (value: T0) => boolean,
-  onFalse: (value: T0) => E
-): <T1 extends T0>(value: T1) => Result<T1, E> {
-  return (value) => {
-    if (refinement(value)) {
-      return ok(value);
-    } else {
-      return err(onFalse(value));
-    }
-  };
-}
-
-// NOTE: Function overload resolution seems to fail when declared as overloaded
-// function type, so a value with a callable type is used instead.
-export const filterOrElse: {
-  <T0, T1 extends T0, E>(
-    refinement: (value: T0) => value is T1,
-    onFalse: (value: T0) => E
-  ): (result: Result<T0, E>) => Result<T1, E>;
-  <T0, E>(refinement: (value: T0) => boolean, onFalse: (value: T0) => E): <
-    T1 extends T0
-  >(
-    result: Result<T1, E>
-  ) => Result<T1, E>;
-} = <T0, E>(
-  refinement: (value: T0) => boolean,
-  onFalse: (value: T0) => E
-): (<T1 extends T0>(result: Result<T1, E>) => Result<T1, E>) => {
-  return (result) => {
-    if (isOk(result)) {
-      if (refinement(result.value)) {
-        return result;
-      } else {
-        return err(onFalse(result.value));
-      }
-    } else {
-      return result;
-    }
-  };
-};

package/src/fp/util.ts

@@ -1,52 +0,0 @@
-export function pipe<A>(a: A): A;
-export function pipe<A, B>(a: A, ab: (a: A) => B): B;
-export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
-export function pipe<A, B, C, D>(
-  a: A,
-  ab: (a: A) => B,
-  bc: (b: B) => C,
-  cd: (c: C) => D
-): D;
-export function pipe<A, B, C, D, E>(
-  a: A,
-  ab: (a: A) => B,
-  bc: (b: B) => C,
-  cd: (c: C) => D,
-  de: (d: D) => E
-): E;
-export function pipe<A, B, C, D, E, F>(
-  a: A,
-  ab: (a: A) => B,
-  bc: (b: B) => C,
-  cd: (c: C) => D,
-  de: (d: D) => E,
-  ef: (e: E) => F
-): F;
-// "Ought to be enough for everybody" -- attributed to E. Åmdal
-export function pipe<A, B, C, D, E, F, G>(
-  a: A,
-  ab: (a: A) => B,
-  bc: (b: B) => C,
-  cd: (c: C) => D,
-  de: (d: D) => E,
-  ef: (e: E) => F,
-  fg: (f: F) => G
-): G;
-export function pipe(a: unknown, ...fns: ((u: unknown) => unknown)[]): unknown {
-  let current = a;
-  for (const fn of fns) {
-    current = fn(current);
-  }
-  return current;
-}
-
-/**
- * Runs the callback with the supplied value, then returns the value. Useful for
- * debugging pipes.
- */
-export function tap<T>(callback: (value: T) => void): (value: T) => T {
-  return (value) => {
-    callback(value);
-    return value;
-  };
-}

package/src/future/fetchVal.test.ts

@@ -1,164 +0,0 @@
-import { initSchema } from "../initSchema";
-import { content } from "../module";
-import { getValPath } from "../val";
-import { serializedValOfSelectorSource, fetchVal } from "./fetchVal";
-
-const s = initSchema();
-// const i18n = initI18n(["en_US", "no_NB"]);
-
-describe("serialization of val", () => {
-  test("serialized val: string", () => {
-    const schema = s.string();
-
-    const testVal = content("/app", schema, "foo");
-
-    expect(serializedValOfSelectorSource(testVal)).toStrictEqual({
-      val: "foo",
-      valPath: "/app",
-    });
-  });
-
-  test("serialized val: array", () => {
-    const schema = s.array(s.string());
-
-    const testVal = content("/app", schema, ["foo", "bar"]);
-
-    expect(serializedValOfSelectorSource(testVal)).toStrictEqual({
-      val: [
-        {
-          val: "foo",
-          valPath: "/app.0",
-        },
-        { val: "bar", valPath: "/app.1" },
-      ],
-      valPath: "/app",
-    });
-
-    //                          ^?
-  });
-
-  test("serialized val: object", () => {
-    const schema = s.object({ foo: s.object({ bar: s.array(s.string()) }) });
-
-    const testVal = content("/app", schema, { foo: { bar: ["foo", "bar"] } });
-
-    expect(serializedValOfSelectorSource(testVal)).toStrictEqual({
-      val: {
-        foo: {
-          val: {
-            bar: {
-              val: [
-                {
-                  val: "foo",
-                  valPath: '/app."foo"."bar".0',
-                },
-                { val: "bar", valPath: '/app."foo"."bar".1' },
-              ],
-              valPath: '/app."foo"."bar"',
-            },
-          },
-          valPath: '/app."foo"',
-        },
-      },
-      valPath: "/app",
-    });
-  });
-});
-
-describe("fetchVal", () => {
-  test("valuate: string", async () => {
-    const schema = s.string();
-
-    const testVal = content("/app", schema, "foo");
-
-    const test = await fetchVal(testVal);
-    //     ^? should be Val<string>
-    expect(test.val).toBe("foo");
-    expect(getValPath(test)).toBe("/app");
-  });
-
-  test("valuate: array", async () => {
-    const schema = s.array(s.string());
-
-    const testVal = content("/app", schema, ["foo", "bar"]);
-
-    const test = await fetchVal(testVal);
-    //      ^? should be Val<string[]>
-    expect(test.val).toStrictEqual(["foo", "bar"]);
-    expect(test[0].val).toStrictEqual("foo");
-    expect(test[1].val).toStrictEqual("bar");
-    expect(getValPath(test[0])).toStrictEqual("/app.0");
-    expect(getValPath(test[1])).toStrictEqual("/app.1");
-  });
-
-  test("valuate: object", async () => {
-    const schema = s.object({ foo: s.object({ bar: s.array(s.string()) }) });
-
-    const testVal = content("/app", schema, { foo: { bar: ["foo", "bar"] } });
-
-    const test = await fetchVal(testVal);
-    //      ^? should be Val<{ foo: { bar: string[] } }>
-
-    expect(test.val).toStrictEqual({ foo: { bar: ["foo", "bar"] } });
-    expect(test.foo.val).toStrictEqual({ bar: ["foo", "bar"] });
-    expect(test.foo.bar.val).toStrictEqual(["foo", "bar"]);
-    expect(test.foo.bar[0].val).toStrictEqual("foo");
-    expect(test.foo.bar[1].val).toStrictEqual("bar");
-    expect(getValPath(test.foo.bar[0])).toStrictEqual('/app."foo"."bar".0');
-    expect(getValPath(test.foo.bar[1])).toStrictEqual('/app."foo"."bar".1');
-  });
-
-  // test("valuate: array with map", async () => {
-  //   const schema = s.array(s.string());
-
-  //   const testVal = content("/app", schema, ["foo", "bar"]);
-
-  //   const test = await fetchVal({
-  //     //    ^? should be Val<{ title: string }[]>
-  //     foo: testVal.map((v) => ({ title: v })),
-  //     test: testVal,
-  //   });
-  //   expect(test.val).toStrictEqual({
-  //     foo: [{ title: "foo" }, { title: "bar" }],
-  //     test: ["foo", "bar"],
-  //   });
-  // });
-
-  // test("valuate: 2 modules with oneOf", async () => {
-  //   const testVal1 = content("/testVal1", s.array(s.string()), [
-  //     "test-val-1-0",
-  //     "test-val-1-1",
-  //   ]);
-  //   const testVal2 = content(
-  //     "/testVal2",
-  //     s.object({ test1: s.oneOf(testVal1), test2: s.string() }),
-  //     {
-  //       test2: "test2 value",
-  //       test1: testVal1[0],
-  //     }
-  //   );
-
-  //   const test = await fetchVal({
-  //     //    ^?
-  //     testVal1: testVal1.map((v) => ({ title: v, otherModule: testVal2 })),
-  //     testVal2: testVal2,
-  //   });
-  //   expect(test.val).toStrictEqual({
-  //     testVal1: [
-  //       {
-  //         title: "test-val-1-0",
-  //         otherModule: { test2: "test2 value", test1: "test-val-1-0" },
-  //       },
-  //       {
-  //         title: "test-val-1-1",
-  //         otherModule: { test2: "test2 value", test1: "test-val-1-0" },
-  //       },
-  //     ],
-  //     testVal2: { test2: "test2 value", test1: "test-val-1-0" },
-  //   });
-  //   expect(getValPath(test.testVal1[0].otherModule.test1)).toStrictEqual(
-  //     "/testVal1.0"
-  //   );
-  //   expect(getValPath(test.testVal2.test2)).toStrictEqual('/testVal2."test2"');
-  // });
-});

package/src/future/fetchVal.ts

@@ -1,206 +0,0 @@
-import {
-  GenericSelector,
-  Path,
-  SelectorOf,
-  SelectorSource,
-  GetSource,
-} from "../selector";
-import {
-  isSerializedVal,
-  JsonOfSource,
-  SerializedVal,
-  SourcePath,
-  Val,
-} from "../val";
-import {
-  createValPathOfItem,
-  isSelector,
-  newSelectorProxy,
-} from "../selector/SelectorProxy";
-import { Json } from "../Json";
-
-export function fetchVal<T extends SelectorSource>(
-  selector: T
-): SelectorOf<T> extends GenericSelector<infer S>
-  ? Promise<Val<JsonOfSource<S>>>
-  : never {
-  return Promise.resolve(
-    getVal(selector) as unknown
-  ) as SelectorOf<T> extends GenericSelector<infer S>
-    ? Promise<Val<JsonOfSource<S>>>
-    : never;
-}
-
-export function getVal<T extends SelectorSource>(
-  selector: T
-): SelectorOf<T> extends GenericSelector<infer S>
-  ? Val<JsonOfSource<S>>
-  : never {
-  return newValProxy(
-    serializedValOfSelectorSource(selector)
-  ) as SelectorOf<T> extends GenericSelector<infer S>
-    ? Val<JsonOfSource<S>>
-    : never;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isArrayOrArraySelector(child: any) {
-  if (isSelector(child)) {
-    return (
-      typeof child[GetSource] === "object" &&
-      typeof child[GetSource] !== null &&
-      Array.isArray(child[GetSource])
-    );
-  }
-  return Array.isArray(child);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isObjectOrObjectSelector(child: any) {
-  if (isSelector(child)) {
-    return (
-      typeof child[GetSource] === "object" &&
-      typeof child[GetSource] !== null &&
-      !Array.isArray(child[GetSource])
-    );
-  }
-  return typeof child === "object";
-}
-
-export function serializedValOfSelectorSource<T extends SelectorSource>(
-  selector: T
-) {
-  const wrappedSelector = newSelectorProxy(selector); // NOTE: we do this if call-site uses a literal with selectors inside
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function rec(child: any): any {
-    const isArray = isArrayOrArraySelector(child);
-    const isObject = isObjectOrObjectSelector(child);
-    if (isArray) {
-      const array = (
-        GetSource in child ? child[GetSource] : child
-      ) as Array<unknown>;
-      const valPath = Path in child ? (child[Path] as SourcePath) : undefined;
-      return {
-        val: array.map((item, i) =>
-          rec(
-            isSelector(item) // NOTE: We do this since selectors currently do not create selectors of items unless specifically required.
-              ? item
-              : newSelectorProxy(item, createValPathOfItem(valPath, i))
-          )
-        ),
-        valPath,
-      };
-    } else if (isObject) {
-      const obj = (GetSource in child ? child[GetSource] : child) as object;
-      const valPath = Path in child ? (child[Path] as SourcePath) : undefined;
-      return {
-        val:
-          obj !== null &&
-          Object.fromEntries(
-            Object.entries(obj).map(([key, value]) => [
-              key,
-              rec(
-                isSelector(value) // NOTE: We do this since selectors currently do not create selectors of items unless specifically required.
-                  ? value
-                  : newSelectorProxy(value, createValPathOfItem(valPath, key))
-              ),
-            ])
-          ),
-        valPath,
-      };
-    } else if (isSelector(child)) {
-      return {
-        val: rec(child[GetSource]),
-        valPath: child[Path],
-      };
-    } else {
-      return child;
-    }
-  }
-
-  return rec(wrappedSelector);
-}
-
-function strip(value: SerializedVal | Json): Json {
-  const val = isSerializedVal(value) ? value.val : value;
-  switch (typeof val) {
-    case "function":
-    case "symbol":
-      throw Error(`Invalid val type: ${typeof val}`);
-    case "object":
-      if (val === null) {
-        return null;
-      } else if (Array.isArray(val)) {
-        return val.map(strip);
-      } else {
-        return Object.fromEntries(
-          Object.entries(val).map(([key, value]) => [
-            key,
-            value && strip(value),
-          ])
-        ) as Json;
-      }
-    // intentional fallthrough
-    // eslint-disable-next-line no-fallthrough
-    default:
-      return val;
-  }
-}
-
-function newValProxy<T extends Json>(val: SerializedVal): Val<T> {
-  const source = val.val;
-  switch (typeof source) {
-    case "function":
-    case "symbol":
-      throw Error(`Invalid val type: ${typeof source}`);
-    case "object":
-      if (source !== null) {
-        // Handles both objects and arrays!
-        return new Proxy(source, {
-          has(target, prop: string | symbol) {
-            if (prop === "val") {
-              return true;
-            }
-            if (prop === Path) {
-              return true;
-            }
-            return hasOwn(target, prop);
-          },
-          get(target, prop: string | symbol) {
-            if (prop === Path) {
-              return val.valPath;
-            }
-            if (prop === "val") {
-              return strip(val);
-            }
-            if (Array.isArray(target) && prop === "length") {
-              return target.length;
-            }
-            if (hasOwn(source, prop)) {
-              return newValProxy({
-                val: Reflect.get(target, prop).val,
-                valPath:
-                  Reflect.get(target, prop)?.valPath ??
-                  createValPathOfItem(
-                    val.valPath,
-                    Array.isArray(target) ? Number(prop) : prop
-                  ),
-              } as SerializedVal);
-            }
-            return Reflect.get(target, prop);
-          },
-        }) as unknown as Val<T>;
-      }
-    // intentional fallthrough
-    // eslint-disable-next-line no-fallthrough
-    default:
-      return {
-        [Path]: val.valPath,
-        val: val.val,
-      } as Val<T>;
-  }
-}
-
-function hasOwn<T extends PropertyKey>(obj: object, prop: T): boolean {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}

package/src/getSha256.ts

@@ -1,8 +0,0 @@
-export const getSHA256Hash = async (bits: Uint8Array) => {
-  const hashBuffer = await crypto.subtle.digest("SHA-256", bits);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hash = hashArray
-    .map((item) => item.toString(16).padStart(2, "0"))
-    .join("");
-  return hash;
-};