@valbuild/core 0.26.0 → 0.27.0

package/src/selector/future/SelectorProxy.test.ts

@@ -1,172 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Selector, GenericSelector, Path } from ".";
-import { number } from "../../schema/number";
-import { string } from "../../schema/string";
-import { Source } from "../../source";
-import { SourcePath } from "../../val";
-import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
-
-describe("SelectorProxy", () => {
-  test("string eq andThen", () => {
-    const sourcePath = "/app/text" as SourcePath;
-    const string1 = newSelectorProxy("foo", sourcePath) as Selector<string>;
-    expectValOrExpr(string1.eq("foo")).toStrictEqual({
-      val: true,
-      [Path]: undefined,
-    });
-    expectValOrExpr(string1.eq("foo").andThen(() => string1)).toStrictEqual({
-      val: "foo",
-      [Path]: sourcePath,
-    });
-  });
-
-  test("array filter eq", () => {
-    const sourcePath = "/app/texts" as SourcePath;
-    const string1 = newSelectorProxy(["foo", "bar"], sourcePath) as Selector<
-      string[]
-    >;
-    expectValOrExpr(
-      string1.map((a) => a).filter((a) => a.eq("foo"))
-    ).toStrictEqual({
-      val: ["foo"],
-      [Path]: "/app/texts",
-    });
-  });
-
-  test("array numbers", () => {
-    const sourcePath = "/app/numbers" as SourcePath;
-    const numbersVal = newSelectorProxy([1, 2, 3], sourcePath) as Selector<
-      string[]
-    >;
-    expectValOrExpr(numbersVal).toStrictEqual({
-      val: [1, 2, 3],
-      [Path]: "/app/numbers",
-    });
-  });
-
-  test("array length", () => {
-    const sourcePath = "/app/numbers" as SourcePath;
-    const numbersVal = newSelectorProxy([1, 2, 3], sourcePath) as Selector<
-      string[]
-    >;
-    expectValOrExpr(numbersVal.length).toStrictEqual({
-      val: 3,
-      [Path]: undefined,
-    });
-  });
-
-  test("array filter match number", () => {
-    const sourcePath = "/app/numbers" as SourcePath;
-    const numbersVal = newSelectorProxy([1, 2, undefined], sourcePath) as
-      | Selector<string[]>
-      | Selector<null[]>;
-    expectValOrExpr(numbersVal.filter(number())).toStrictEqual({
-      val: [1, 2],
-      [Path]: "/app/numbers",
-    });
-  });
-
-  test("array filter match string / undefined / null", () => {
-    const sourcePath = "/app/numbers" as SourcePath;
-    const numbersVal = newSelectorProxy(
-      [1, 2, undefined, null, "test"],
-      sourcePath
-    ) as Selector<(number | string | null)[]>;
-    expectValOrExpr(numbersVal.filter(string().optional())).toStrictEqual({
-      val: [null, null, "test"],
-      [Path]: "/app/numbers",
-    });
-  });
-
-  test("object lookup", () => {
-    const sourcePath = "/app/blog" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      { title: "title1" },
-      sourcePath
-    ) as Selector<{ title: string }>;
-    expectValOrExpr(blogsVal).toStrictEqual({
-      val: { title: "title1" },
-      [Path]: "/app/blog",
-    });
-  });
-
-  test("object prop", () => {
-    const sourcePath = "/app/blog" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      { title: "title1" },
-      sourcePath
-    ) as Selector<{ title: string }>;
-    expectValOrExpr(blogsVal.title).toStrictEqual({
-      val: "title1",
-      [Path]: '/app/blog."title"',
-    });
-  });
-
-  test("array object index", () => {
-    const sourcePath = "/app/blogs" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      [{ title: "title1" }],
-      sourcePath
-    ) as Selector<{ title: string }[]>;
-    expectValOrExpr(blogsVal[0]).toStrictEqual({
-      val: {
-        title: "title1",
-      },
-      [Path]: "/app/blogs.0",
-    });
-  });
-
-  test("array map object index", () => {
-    const sourcePath = "/app/blogs" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      [{ title: "title1" }],
-      sourcePath
-    ) as Selector<{ title: string }[]>;
-    expectValOrExpr(blogsVal.map((v) => v)[0]).toStrictEqual({
-      val: {
-        title: "title1",
-      },
-      [Path]: "/app/blogs.0",
-    });
-  });
-
-  test("map object then index", () => {
-    const sourcePath = "/app/blogs" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      [{ title: "title1" }],
-      sourcePath
-    ) as Selector<{ title: string }[]>;
-    expectValOrExpr(blogsVal.map((blog) => blog)).toStrictEqual({
-      val: [{ title: "title1" }],
-      [Path]: "/app/blogs",
-    });
-  });
-
-  test("map object then index then prop", () => {
-    const sourcePath = "/app/blogs" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      [{ title: "title1" }, { title: "title2" }],
-      sourcePath
-    ) as Selector<{ title: string }[]>;
-    expectValOrExpr(blogsVal.map((blog) => blog)[0].title).toStrictEqual({
-      val: "title1",
-      [Path]: '/app/blogs.0."title"',
-    });
-  });
-
-  test("map object then prop then index", () => {
-    const sourcePath = "/app/blogs" as SourcePath;
-    const blogsVal = newSelectorProxy(
-      [{ title: "title1" }, { title: "title2" }],
-      sourcePath
-    ) as Selector<{ title: string }[]>;
-    expectValOrExpr(blogsVal.map((blog) => blog.title)[0]).toStrictEqual({
-      val: "title1",
-      [Path]: '/app/blogs.0."title"',
-    });
-  });
-});
-
-function expectValOrExpr<T extends Source>(selector: GenericSelector<T>) {
-  return expect(selectorToVal(selector));
-}

package/src/selector/future/SelectorProxy.ts

@@ -1,238 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Path, GenericSelector, SourceOrExpr, GetSchema } from ".";
-import { Expr } from "../../expr/expr";
-import { Schema } from "../../schema";
-import { convertFileSource } from "../../schema/image";
-import { Source, SourcePrimitive, VAL_EXTENSION } from "../../source";
-import { FILE_REF_PROP } from "../../source/file";
-import { isSerializedVal, SourcePath } from "../../val";
-
-function hasOwn<T extends PropertyKey>(obj: object, prop: T): boolean {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-function andThen(f: (...args: any[]) => any, source: any, path?: SourcePath) {
-  if (source) {
-    return newSelectorProxy(f(newSelectorProxy(source, path)));
-  }
-  return newSelectorProxy(source, path);
-}
-
-export function isSelector(source: any): source is GenericSelector<Source> {
-  return (
-    typeof source === "object" &&
-    source !== null &&
-    (SourceOrExpr in source || Path in source)
-  );
-}
-
-export function newSelectorProxy(
-  source: any,
-  path?: SourcePath,
-  moduleSchema?: any
-): any {
-  if (typeof source === "object") {
-    if (isSelector(source)) {
-      return source;
-    } else if (isSerializedVal(source)) {
-      return newSelectorProxy(source.val, source.valPath);
-    }
-  }
-
-  if (source && source[FILE_REF_PROP] && source[VAL_EXTENSION] === "file") {
-    const fileRef = source[FILE_REF_PROP];
-    if (typeof fileRef !== "string") {
-      throw Error("Invalid file ref: " + fileRef);
-    }
-    return newSelectorProxy(convertFileSource(source), path, moduleSchema);
-  }
-
-  switch (typeof source) {
-    case "function":
-    case "symbol":
-      throw Error(`Invalid selector type: ${typeof source}: ${source}`);
-    case "object":
-      // Handles both objects and arrays!
-      if (source !== null) {
-        return new Proxy(source, {
-          // TODO: see proxy docs if we want more traps
-          has(target, prop: string | symbol) {
-            if (prop === SourceOrExpr) {
-              return true;
-            }
-            if (prop === Path) {
-              return true;
-            }
-            if (prop === "andThen") {
-              return true;
-            }
-            if (prop === GetSchema) {
-              return true;
-            }
-            return prop in target;
-          },
-          get(target, prop: string | symbol) {
-            if (prop === SourceOrExpr) {
-              return source;
-            }
-            if (prop === Path) {
-              return path;
-            }
-            if (prop === GetSchema) {
-              return moduleSchema;
-            }
-            if (prop === "andThen") {
-              return (f: any) => andThen(f, source, path);
-            }
-            if (Array.isArray(target)) {
-              if (prop === "filter") {
-                return (f: any) => {
-                  const filtered = target
-                    .map((a, i) =>
-                      newSelectorProxy(
-                        a,
-                        createValPathOfItem(path, i),
-                        moduleSchema?.item
-                      )
-                    )
-                    .filter((a) => {
-                      if (f && f instanceof Schema) {
-                        return f.assert(unValify(a));
-                      } else {
-                        return unValify(f(a));
-                      }
-                    });
-                  return newSelectorProxy(filtered, path, moduleSchema);
-                };
-              } else if (prop === "map") {
-                return (f: any) => {
-                  const filtered = target.map((a, i) => {
-                    const valueOrSelector = f(
-                      newSelectorProxy(
-                        a,
-                        createValPathOfItem(path, i),
-                        moduleSchema?.item
-                      ),
-                      newSelectorProxy(i)
-                    );
-                    if (isSelector(valueOrSelector)) {
-                      return valueOrSelector;
-                    }
-                    return newSelectorProxy(valueOrSelector);
-                  });
-                  return newSelectorProxy(filtered, path, moduleSchema);
-                };
-              }
-            }
-            if (Array.isArray(target) && prop === "length") {
-              return newSelectorProxy(target.length);
-            }
-            const reflectedValue = Reflect.get(target, prop);
-
-            if (hasOwn(source, prop)) {
-              if (!Number.isNaN(Number(prop))) {
-                return newSelectorProxy(
-                  reflectedValue,
-                  createValPathOfItem(path, Number(prop)),
-                  moduleSchema?.item
-                );
-              }
-              return newSelectorProxy(
-                reflectedValue,
-                createValPathOfItem(path, prop),
-                moduleSchema?.items[prop]
-              );
-            }
-            return reflectedValue;
-          },
-        });
-      }
-    // intentional fallthrough
-    // eslint-disable-next-line no-fallthrough
-    default:
-      return {
-        eq: (other: SourcePrimitive | GenericSelector<Source>) => {
-          let otherValue: any = other;
-          if (isSelector(other)) {
-            otherValue = other[SourceOrExpr];
-            if (otherValue instanceof Expr) {
-              throw Error("TODO: Cannot evaluate equality with an Expr");
-            }
-          }
-          return newSelectorProxy(source === otherValue, undefined);
-        },
-        andThen: (f: any) => {
-          return andThen(f, source === undefined ? null : source, path);
-        },
-        [SourceOrExpr]: source === undefined ? null : source,
-        [Path]: path,
-        [GetSchema]: moduleSchema,
-      };
-  }
-}
-
-function selectorAsVal(sel: any): any {
-  if (isSerializedVal(sel)) {
-    // is a serialized val
-    return selectorAsVal(newSelectorProxy(sel.val, sel.valPath));
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    !(SourceOrExpr in sel) &&
-    !Array.isArray(sel)
-  ) {
-    // is object
-    return Object.fromEntries(
-      Object.entries(sel).map(([k, v]) => [k, selectorAsVal(v)])
-    );
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    !(SourceOrExpr in sel) &&
-    Array.isArray(sel)
-  ) {
-    // is array
-    return sel.map((v) => selectorAsVal(v));
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    (SourceOrExpr in sel || Path in sel)
-  ) {
-    return selectorAsVal(sel?.[SourceOrExpr]);
-  } else if (sel === undefined) {
-    return null;
-  }
-  return sel;
-}
-
-export function createValPathOfItem(
-  arrayPath: SourcePath | undefined,
-  prop: string | number | symbol
-) {
-  if (typeof prop === "symbol") {
-    throw Error(
-      `Cannot create val path of array item with symbol prop: ${prop.toString()}`
-    );
-  }
-  return arrayPath && (`${arrayPath}.${JSON.stringify(prop)}` as SourcePath);
-}
-
-export function selectorToVal(s: any): any {
-  const v = selectorAsVal(s?.[SourceOrExpr]);
-  return {
-    val: v,
-    [Path]: s?.[Path],
-  };
-}
-
-// TODO: could we do .val on the objects instead?
-function unValify(valueOrSelector: any) {
-  if (
-    typeof valueOrSelector === "object" &&
-    (SourceOrExpr in valueOrSelector || Path in valueOrSelector)
-  ) {
-    const selectorValue = valueOrSelector[SourceOrExpr];
-    return selectorValue;
-  }
-  return valueOrSelector;
-}

package/src/selector/future/array.ts

@@ -1,37 +0,0 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
-import { Schema } from "../../schema";
-import { Source, SourceArray } from "../../source";
-import { Selector as BooleanSelector } from "./boolean";
-import { Selector as NumberSelector } from "./number";
-
-export type UndistributedSourceArray<T extends SourceArray> = [T] extends [
-  infer U // infer here to avoid Type instantiation is excessively deep and possibly infinite. See: https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437. Avoiding infer extends to keep us below TS 4.9 compat
-]
-  ? U extends Source[]
-    ? Selector<U>
-    : never
-  : never;
-
-// TODO: docs
-export type Selector<T extends SourceArray> = GenericSelector<T> & {
-  readonly [key: number]: UnknownSelector<T[number]>;
-} & {
-  length: NumberSelector<number>;
-  filter(
-    predicate: (
-      v: UnknownSelector<T[number]>
-    ) => BooleanSelector<boolean> | boolean
-  ): Selector<T>;
-  filter<U extends Source>(schema: Schema<U>): Selector<U[]>;
-  map<U extends SelectorSource>(
-    f: (v: UnknownSelector<T[number]>, i: UnknownSelector<number>) => U
-  ): SelectorOf<U[]>; // TODO: this should be SelectorOf<ArraySelectorSourceBranded<U[]>>;
-  andThen<U extends SelectorSource>(
-    f: (v: UnknownSelector<NonNullable<T>>) => U
-  ): SelectorOf<U | T>;
-};

package/src/selector/future/boolean.ts

@@ -1,4 +0,0 @@
-import { Selector as PrimitiveSelector } from "./primitive";
-
-// TODO: docs
-export type Selector<T extends boolean> = PrimitiveSelector<T>;

package/src/selector/future/file.ts

@@ -1,14 +0,0 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
-
-// TODO: docs
-export type FileSelector = GenericSelector<{ url: string }> & {
-  readonly url: UnknownSelector<string>;
-  andThen<U extends SelectorSource>(
-    f: (v: UnknownSelector<NonNullable<{ url: string }>>) => U
-  ): SelectorOf<U> | UnknownSelector<boolean>;
-};

package/src/selector/future/i18n.ts

@@ -1,13 +0,0 @@
-import { SourceArray, SourceObject, SourcePrimitive } from "../../source";
-import { Selector as UnknownSelector } from ".";
-import { FileSource } from "../../source/file";
-
-declare const brand: unique symbol;
-
-export type I18nSelector<
-  Locales extends readonly string[],
-  T extends SourcePrimitive | SourceObject | SourceArray | FileSource
-> = UnknownSelector<T> & {
-  readonly [brand]: "I18nSelector";
-  all(): { [locale in Locales[number]]: UnknownSelector<T> };
-};

package/src/selector/future/index.ts

@@ -1,169 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { I18nSelector } from "./i18n";
-import { Selector as ObjectSelector } from "./object";
-import { UndistributedSourceArray as ArraySelector } from "./array";
-import { Selector as NumberSelector } from "./number";
-import { Selector as StringSelector } from "./string";
-import { Selector as BooleanSelector } from "./boolean";
-import { Selector as PrimitiveSelector } from "./primitive";
-import { FileSelector } from "./file";
-import { SourcePath } from "../../val";
-import {
-  Source,
-  SourceArray,
-  SourceObject,
-  SourcePrimitive,
-} from "../../source";
-import { Schema } from "../../schema";
-import { Expr } from "../../expr/expr";
-import { RemoteSelector } from "./remote";
-import type { A } from "ts-toolbelt";
-import { I18nSource, I18nCompatibleSource } from "../../source/future/i18n";
-import {
-  RemoteCompatibleSource,
-  RemoteSource,
-} from "../../source/future/remote";
-import { FileSource } from "../../source/file";
-import {
-  AnyRichTextOptions,
-  RichText,
-  RichTextSource,
-} from "../../source/richtext";
-
-/**
- * Selectors can be used to select parts of a Val module.
- * Unlike queries, joins, aggregates etc is and will not be supported.
- *
- * They are designed to be be used as if they were "normal" JSON data,
- * though some concessions had to be made because of TypeScript limitations.
- *
- * Selectors works equally on source content, defined in code, and remote content.
- *
- * @example
- * // Select the title of a document
- * const titles = useVal(docsVal.map((doc) => doc.title));
- *
- * @example
- * // Match on a union type
- * const titles = useVal(docsVal.map((doc) => doc.fold("type")({
- *   newsletter: (newsletter) => newsletter.title,
- *   email: (email) => email.subject,
- * }));
- *
- */
-export type Selector<T extends Source> = Source extends T
-  ? GenericSelector<T>
-  : T extends I18nSource<infer L, infer S>
-  ? I18nSelector<L, S>
-  : T extends RemoteSource<infer S>
-  ? S extends RemoteCompatibleSource
-    ? RemoteSelector<S>
-    : GenericSelector<Source, "Could not determine remote source">
-  : T extends FileSource
-  ? FileSelector
-  : T extends RichTextSource<infer O>
-  ? RichText<O>
-  : T extends SourceObject
-  ? ObjectSelector<T>
-  : T extends SourceArray
-  ? ArraySelector<T>
-  : T extends string
-  ? StringSelector<T>
-  : T extends number
-  ? NumberSelector<T>
-  : T extends boolean
-  ? BooleanSelector<T>
-  : T extends null
-  ? PrimitiveSelector<null>
-  : never;
-
-export type SelectorSource =
-  | SourcePrimitive
-  | undefined
-  | readonly SelectorSource[]
-  | {
-      [key: string]: SelectorSource;
-    }
-  | I18nSource<readonly string[], I18nCompatibleSource>
-  | RemoteSource<RemoteCompatibleSource>
-  | FileSource
-  | RichTextSource<AnyRichTextOptions>
-  | GenericSelector<Source>;
-
-/**
- * @internal
- */
-export const GetSchema = Symbol("GetSchema");
-/**
-/**
- * @internal
- */
-export const Path = Symbol("Path");
-/**
- * @internal
- */
-export const SourceOrExpr = Symbol("SourceOrExpr");
-/**
- * @internal
- */
-export const ValError = Symbol("ValError");
-export abstract class GenericSelector<
-  out T extends Source,
-  Error extends string | undefined = undefined
-> {
-  readonly [Path]: SourcePath | undefined;
-  readonly [SourceOrExpr]: T | Expr;
-  readonly [ValError]: Error | undefined;
-  readonly [GetSchema]: Schema<T> | undefined;
-  constructor(
-    valOrExpr: T,
-    path: SourcePath | undefined,
-    schema?: Schema<T>,
-    error?: Error
-  ) {
-    this[Path] = path;
-    this[SourceOrExpr] = valOrExpr;
-    this[ValError] = error;
-    this[GetSchema] = schema;
-  }
-
-  assert<U extends Source, E extends Source = null>(
-    schema: Schema<U>,
-    other?: () => E
-  ): SelectorOf<U | E> {
-    throw new Error("Not implemented");
-  }
-}
-
-export type SourceOf<T extends SelectorSource> = Source extends T
-  ? Source
-  : T extends Source
-  ? T
-  : T extends undefined
-  ? null
-  : T extends GenericSelector<infer S>
-  ? S
-  : T extends readonly (infer S)[] // NOTE: the infer S instead of Selector Source here, is to avoid infinite recursion
-  ? S extends SelectorSource
-    ? {
-        [key in keyof T]: SourceOf<A.Try<T[key], SelectorSource>>;
-      }
-    : never
-  : T extends { [key: string]: SelectorSource }
-  ? {
-      [key in keyof T]: SourceOf<A.Try<T[key], SelectorSource>>;
-    }
-  : never;
-
-/**
- * Use this type to convert types that accepts both Source and Selectors
- *
- * An example would be where literals are supported like in most higher order functions (e.g. map in array)
- **/
-export type SelectorOf<U extends SelectorSource> = Source extends U
-  ? GenericSelector<Source>
-  : SourceOf<U> extends infer S // we need this to avoid infinite recursion
-  ? S extends Source
-    ? Selector<S>
-    : GenericSelector<Source, "Could not determine selector of source">
-  : GenericSelector<Source, "Could not determine source">;

package/src/selector/future/number.ts

@@ -1,4 +0,0 @@
-import { Selector as PrimitiveSelector } from "./primitive";
-
-// TODO:
-export type Selector<T extends number> = PrimitiveSelector<T>;

package/src/selector/future/object.ts

@@ -1,22 +0,0 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
-import { SourceObject } from "../../source";
-
-// TODO: docs
-export type Selector<T extends SourceObject> = GenericSelector<T> & {
-  fold<Tag extends string>(
-    key: Tag
-  ): <U extends SelectorSource>(cases: {
-    [key in T[Tag & keyof T] & string]: (v: UnknownSelector<T>) => U;
-  }) => SelectorOf<U>;
-
-  andThen<U extends SelectorSource>(
-    f: (v: UnknownSelector<NonNullable<T>>) => U
-  ): SelectorOf<U>;
-} & {
-  readonly [key in keyof T]: UnknownSelector<T[key]>;
-};

package/src/selector/future/primitive.ts

@@ -1,17 +0,0 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
-import { Source, SourcePrimitive } from "../../source";
-import { Selector as BooleanSelector } from "./boolean";
-
-export type Selector<T extends SourcePrimitive> = GenericSelector<T> & {
-  eq(other: Source): BooleanSelector<boolean>;
-  andThen<U extends SelectorSource>(
-    f: (v: UnknownSelector<NonNullable<T>>) => U
-  ): SelectorOf<U | NullableOf<T>>;
-};
-
-type NullableOf<T extends Source> = T extends null ? null : never;