@valbuild/core 0.12.0 → 0.13.1

package/src/fetchVal.test.ts

@@ -0,0 +1,164 @@
+import { initSchema } from "./initSchema";
+import { content } from "./module";
+import { getValPath } from "./val";
+import { serializedValOfSelectorSource, fetchVal } from "./fetchVal";
+
+const s = initSchema(["en_US", "no_NB"]);
+// 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/fetchVal.ts

@@ -0,0 +1,211 @@
+import {
+  GenericSelector,
+  Path,
+  SelectorOf,
+  SelectorSource,
+  SourceOrExpr,
+} 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,
+  locale?: string
+): SelectorOf<T> extends GenericSelector<infer S>
+  ? Promise<Val<JsonOfSource<S>>>
+  : never {
+  return Promise.resolve(
+    getVal(selector, locale) as unknown
+  ) as SelectorOf<T> extends GenericSelector<infer S>
+    ? Promise<Val<JsonOfSource<S>>>
+    : never;
+}
+
+export function getVal<T extends SelectorSource>(
+  selector: T,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  locale?: string
+): 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[SourceOrExpr] === "object" &&
+      typeof child[SourceOrExpr] !== null &&
+      Array.isArray(child[SourceOrExpr])
+    );
+  }
+  return Array.isArray(child);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObjectOrObjectSelector(child: any) {
+  if (isSelector(child)) {
+    return (
+      typeof child[SourceOrExpr] === "object" &&
+      typeof child[SourceOrExpr] !== null &&
+      !Array.isArray(child[SourceOrExpr])
+    );
+  }
+  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 = (
+        SourceOrExpr in child ? child[SourceOrExpr] : 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 = (
+        SourceOrExpr in child ? child[SourceOrExpr] : 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[SourceOrExpr]),
+        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/fp/array.ts

@@ -0,0 +1,30 @@
+export type NonEmptyArray<T> = [T, ...T[]];
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+
+export function isNonEmpty<T>(array: Array<T>): array is NonEmptyArray<T>;
+export function isNonEmpty<T>(
+  array: ReadonlyArray<T>
+): array is ReadonlyNonEmptyArray<T> {
+  return array.length > 0;
+}
+
+export function flatten<T>(
+  array: ReadonlyNonEmptyArray<ReadonlyNonEmptyArray<T>>
+): NonEmptyArray<T>;
+export function flatten<T>(array: ReadonlyArray<ReadonlyArray<T>>): Array<T> {
+  return array.flat(1);
+}
+
+export function map<T, U>(
+  fn: (value: T, index: number) => U
+): {
+  (array: ReadonlyArray<T>): Array<U>;
+  (array: ReadonlyNonEmptyArray<T>): NonEmptyArray<U>;
+} {
+  function mapFn(array: ReadonlyArray<T>): Array<U>;
+  function mapFn(array: ReadonlyNonEmptyArray<T>): NonEmptyArray<U>;
+  function mapFn(array: ReadonlyArray<T>): Array<U> {
+    return array.map(fn);
+  }
+  return mapFn;
+}

package/src/fp/index.ts

@@ -0,0 +1,3 @@
+export * as result from "./result";
+export * as array from "./array";
+export * from "./util";

package/src/fp/result.ts

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,52 @@
+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;
+  };
+}