@valbuild/core 0.26.0 → 0.27.0

package/src/selector/future/remote.ts

@@ -1,9 +0,0 @@
-import { Selector as UnknownSelector } from ".";
-import { RemoteCompatibleSource } from "../../source/future/remote";
-
-declare const brand: unique symbol;
-
-export type RemoteSelector<T extends RemoteCompatibleSource> =
-  UnknownSelector<T> & {
-    readonly [brand]: "RemoteSelector";
-  };

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

@@ -1,429 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Selector, GenericSelector, SourceOrExpr, Path } from ".";
-import { string } from "../../schema/string";
-import { array } from "../../schema/array";
-import { SourcePath } from "../../val";
-import { Source } from "../../source";
-import { evaluate } from "../../expr/eval";
-import { result } from "../../fp";
-import { object } from "../../schema/object";
-import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
-import { newExprSelectorProxy, root } from "./ExprProxy";
-
-const modules = {
-  "/app/text": "text1",
-  "/app/texts": ["text1", "text2"] as string[],
-  "/app/blog": { title: "blog1", text: "text1" } as {
-    title: string | null;
-    text: string;
-  },
-  "/app/blogs": [
-    { title: "blog1", text: "text1" },
-    { title: undefined, text: "text2" },
-  ] as { title: string | null; text: string }[],
-  "/app/empty": "",
-  "/app/large/nested": BFV(),
-};
-
-const SelectorModuleTestCases: {
-  description: string;
-  input: (remote: boolean) => GenericSelector<Source>;
-  expected: Expected;
-}[] = [
-  {
-    description: "string module lookup",
-    input: (remote) => testModule("/app/text", remote),
-    expected: {
-      val: "text1",
-      [Path]: "/app/text",
-    },
-  },
-  {
-    description: "basic eq",
-    input: (remote) => testModule("/app/text", remote).eq("text1"),
-    expected: {
-      val: true,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "andThen noop",
-    input: (remote) => testModule("/app/text", remote).andThen((v) => v),
-    expected: {
-      val: "text1",
-      [Path]: "/app/text",
-    },
-  },
-  {
-    description: "array module lookup",
-    input: (remote) => testModule("/app/texts", remote),
-    expected: {
-      val: ["text1", "text2"],
-      [Path]: "/app/texts",
-    },
-  },
-  {
-    description: "string andThen eq",
-    input: (remote) =>
-      testModule("/app/text", remote).andThen((v) => v.eq("text1")),
-    expected: {
-      val: true,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "empty string andThen eq",
-    input: (remote) =>
-      testModule("/app/empty", remote).andThen((v) => v.eq("text1")),
-    expected: {
-      val: "",
-      [Path]: "/app/empty",
-    },
-  },
-  {
-    description: "andThen literal eq",
-    input: (remote) =>
-      testModule("/app/text", remote)
-        .andThen(() => "foo")
-        .eq("foo"),
-    expected: {
-      val: true,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "andThen undefined literal eq",
-    input: (remote) =>
-      testModule("/app/text", remote)
-        .andThen(() => undefined)
-        .eq("foo"),
-    expected: {
-      val: false,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "empty andThen literal eq",
-    input: (remote) =>
-      testModule("/app/empty", remote)
-        .andThen(() => "foo")
-        .eq("foo"),
-    expected: {
-      val: false,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "string andThen array literal and index",
-    input: (remote) =>
-      testModule("/app/text", remote).andThen((v) => [v, "text2"])[0],
-    expected: { val: "text1", [Path]: "/app/text" },
-  },
-  {
-    description: "string map undefined -> null literal conversion",
-    input: (remote) =>
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      testModule("/app/blogs", remote).map((v) => ({ title: undefined })),
-    expected: {
-      val: [{ title: null }, { title: null }],
-      [Path]: "/app/blogs",
-    },
-  },
-  {
-    description: "array map noop",
-    input: (remote) => testModule("/app/texts", remote).map((v) => v),
-    expected: { val: ["text1", "text2"], [Path]: "/app/texts" },
-  },
-  {
-    description: "array map projection with undefined",
-    input: (remote) =>
-      testModule("/app/blogs", remote).map((v) => ({
-        otherTitle: v.title,
-        other: undefined,
-      })),
-    expected: {
-      val: [
-        { otherTitle: "blog1", other: null },
-        { otherTitle: null, other: null },
-      ],
-      [Path]: "/app/blogs",
-    },
-  },
-  {
-    description: "array index with eq",
-    input: (remote) => testModule("/app/texts", remote)[0].eq("text1"),
-    expected: { val: true, [Path]: undefined },
-  },
-  {
-    description: "object module lookup",
-    input: (remote) => testModule("/app/blog", remote),
-    expected: { val: { text: "text1", title: "blog1" }, [Path]: "/app/blog" },
-  },
-  {
-    description: "object andThen property lookup",
-    input: (remote) => testModule("/app/blog", remote).andThen((v) => v.title),
-    expected: { val: "blog1", [Path]: '/app/blog."title"' },
-  },
-  {
-    description: "array object manipulation: basic indexed obj",
-    input: (remote) =>
-      testModule("/app/blogs", remote)
-        .map((v) => v)[0]
-        .title.eq("blog1"),
-    expected: {
-      val: true,
-      [Path]: undefined,
-    },
-  },
-  {
-    description: "array object manipulation: filter",
-    input: (remote) =>
-      testModule("/app/blogs", remote).filter((v) => v.title.eq("blog1")),
-    expected: {
-      val: [{ text: "text1", title: "blog1" }],
-      [Path]: "/app/blogs",
-    },
-  },
-  {
-    description: "array object manipulation: map with tuple literal",
-    input: (remote) =>
-      testModule("/app/blogs", remote).map((a) => [1, a.title]),
-    expected: {
-      val: [
-        [1, "blog1"],
-        [1, null],
-      ],
-      [Path]: "/app/blogs",
-    },
-  },
-  // TODO: tuple literal was reverted
-  // {
-  //   description: "array object manipulation: map with tuple literal",
-  //   input: (remote) =>
-  //     testModule("/app/blogs", remote).map((a) => [1, a])[0][1].title,
-  //   expected: {
-  //     val: "blog1",
-  //     [Path]: "/app/blogs.0.title",
-  //   },
-  // },
-  {
-    description: "array object manipulation: with literals",
-    input: (remote) =>
-      testModule("/app/blogs", remote)
-        .map((v) => ({
-          title: {
-            foo: "string",
-          },
-          subTitle: { bar: v.title },
-        }))[0]
-        .title.foo.eq("string"),
-    expected: { val: true, [Path]: undefined },
-  },
-  {
-    description: "array object manipulation: with literals",
-    input: (remote) =>
-      testModule("/app/blogs", remote)
-        .map((v) => [v.title, v.title])[0][0]
-        .eq("blog1"),
-    expected: { val: true, [Path]: undefined },
-  },
-  {
-    description: "array object manipulation: with large nested objects",
-    input: (remote) =>
-      testModule("/app/large/nested", remote).map((v) => ({
-        title: {
-          foo: "string",
-        },
-        subTitle: { bar: v },
-      }))[0].subTitle.bar.that.even.more.even[0].more.even.more.even.more,
-    expected: {
-      val: "that.even.more.even.more",
-      [Path]:
-        '/app/large/nested.0."that"."even"."more"."even".0."more"."even"."more"."even"."more"',
-    },
-  },
-];
-
-const RemoteAndLocaleSelectorModuleTestCases = SelectorModuleTestCases.flatMap(
-  (testCase) => [
-    {
-      input: () => testCase.input(false),
-      description: `local ${testCase.description}`,
-      expected: testCase.expected,
-      remote: false,
-    },
-    {
-      input: () => testCase.input(true),
-      description: `remote ${testCase.description}`,
-      expected: testCase.expected,
-      remote: true,
-    },
-  ]
-);
-
-describe("selector", () => {
-  test.each(RemoteAndLocaleSelectorModuleTestCases)(
-    "$description",
-    ({ input, expected, remote }) => {
-      if (input instanceof Error) {
-        throw input;
-      }
-      // TODO: ideally we should be able to evaluate remote and local
-      if (!remote) {
-        const localeRes = input();
-        expect(selectorToVal(localeRes)).toStrictEqual(expected);
-      } else {
-        const res = evaluate(
-          // @ts-expect-error TODO: fix this
-          input()[SourceOrExpr],
-          (path) => modules[path as keyof typeof modules],
-          []
-        );
-        if (result.isErr(res)) {
-          throw res.error;
-        }
-        expect(selectorToVal(res.value)).toStrictEqual(
-          // NOTE: all expected values for REMOTE should be changed to return Vals
-          expected
-        );
-      }
-    }
-  );
-});
-
-type TestModules = typeof modules;
-
-type Expected = any; // TODO: should be Val | Expr
-
-function testModule<P extends keyof TestModules>(
-  sourcePath: P,
-  remote: boolean
-): Selector<TestModules[P]> {
-  try {
-    if (remote) {
-      return newExprSelectorProxy(
-        root(sourcePath as SourcePath)
-      ) as unknown as Selector<TestModules[P]>;
-    }
-    return newSelectorProxy(modules[sourcePath], sourcePath as SourcePath);
-  } catch (e) {
-    // avoid failing all test suite failure on test case creation, instead returns error and throws it inside the test
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return e as any;
-  }
-}
-
-/** A big schema */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function BFS() {
-  return array(
-    object({
-      title: object({
-        foo: object({
-          inner: array(
-            object({
-              innerInnerTitle: object({
-                even: object({
-                  more: string(),
-                }),
-              }),
-            })
-          ),
-        }),
-      }),
-      bar: string(),
-      many: array(string()),
-      props: string(),
-      are: string(),
-      here: object({
-        even: object({
-          more: string(),
-        }),
-      }),
-      for: string(),
-      testing: string(),
-      purposes: string(),
-      and: string(),
-      to: string(),
-      make: string(),
-      sure: string(),
-      that: object({
-        even: object({
-          more: object({
-            even: array(
-              object({
-                more: object({
-                  even: object({
-                    more: object({
-                      even: object({
-                        more: string(),
-                      }),
-                    }),
-                  }),
-                }),
-              })
-            ),
-          }),
-        }),
-      }),
-      the: string(),
-      type: string(),
-      system: string(),
-      works: string(),
-      as: string(),
-      expected: string(),
-    })
-  );
-}
-
-/** A big value */
-function BFV() {
-  return [
-    {
-      title: {
-        foo: {
-          inner: [
-            {
-              innerInnerTitle: {
-                even: { more: "inner.innerInnerTitle.even.more" },
-              },
-            },
-          ],
-        },
-      },
-      bar: "bar",
-      many: ["many1", "many2", "many3"],
-      props: "props",
-      are: "are",
-      here: { even: { more: "here.even.more" } },
-      for: "for",
-      testing: "testing",
-      purposes: "purposes",
-      and: "and",
-      to: "to",
-      make: "make",
-      sure: "sure",
-      that: {
-        even: {
-          more: {
-            even: [
-              {
-                more: {
-                  even: {
-                    more: { even: { more: "that.even.more.even.more" } },
-                  },
-                },
-              },
-            ],
-          },
-        },
-      },
-      the: "the",
-      type: "type",
-      system: "system",
-      works: "works",
-      as: "as",
-      expected: "expected",
-    },
-  ];
-}

package/src/selector/future/selectorOf.ts

@@ -1,7 +0,0 @@
-import { Selector } from ".";
-import { newSelectorProxy } from "./SelectorProxy";
-import { Source } from "../../source";
-
-export function selectorOf<T extends Source>(t: T): Selector<T> {
-  return newSelectorProxy(t);
-}

package/src/selector/future/string.ts

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

package/src/selector/index.ts

@@ -1,121 +0,0 @@
-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 type { A } from "ts-toolbelt";
-import { FileSource } from "../source/file";
-import { RichText, RichTextOptions, RichTextSource } from "../source/richtext";
-
-export type Selector<T extends Source> = Source extends T
-  ? GenericSelector<T>
-  : 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;
-    }
-  | FileSource
-  | RichTextSource<RichTextOptions>
-  | GenericSelector<Source>;
-
-/**
- * @internal
- */
-export const GetSchema = Symbol("GetSchema");
-/**
-/**
- * @internal
- */
-export const Path = Symbol("Path");
-/**
- * @internal
- */
-export const GetSource = Symbol("GetSource");
-/**
- * @internal
- */
-export const ValError = Symbol("ValError");
-export abstract class GenericSelector<
-  out T extends Source,
-  Error extends string | undefined = undefined
-> {
-  readonly [Path]: SourcePath | undefined;
-  readonly [GetSource]: T;
-  readonly [ValError]: Error | undefined;
-  readonly [GetSchema]: Schema<T> | undefined;
-  constructor(
-    valOrExpr: T,
-    path: SourcePath | undefined,
-    schema?: Schema<T>,
-    error?: Error
-  ) {
-    this[Path] = path;
-    this[GetSource] = valOrExpr;
-    this[ValError] = error;
-    this[GetSchema] = schema;
-  }
-}
-
-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">;
-
-export function getSchema(
-  selector: Selector<Source>
-): Schema<SelectorSource> | undefined {
-  return selector[GetSchema];
-}

package/src/selector/number.ts

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

package/src/selector/object.ts

@@ -1,5 +0,0 @@
-import { GenericSelector } from "./index";
-import { SourceObject } from "../source";
-
-// TODO: docs
-export type Selector<T extends SourceObject> = GenericSelector<T>;

package/src/selector/primitive.ts

@@ -1,4 +0,0 @@
-import { GenericSelector } from "./index";
-import { SourcePrimitive } from "../source";
-
-export type Selector<T extends SourcePrimitive> = GenericSelector<T>;

package/src/selector/string.ts

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

package/src/source/file.ts

@@ -1,45 +0,0 @@
-import { VAL_EXTENSION } from ".";
-import { JsonPrimitive } from "../Json";
-
-export const FILE_REF_PROP = "_ref" as const;
-
-/**
- * A file source represents the path to a (local) file.
- *
- * It will be resolved into a Asset object.
- *
- */
-export type FileSource<
-  Metadata extends { readonly [key: string]: JsonPrimitive } | undefined =
-    | { readonly [key: string]: JsonPrimitive }
-    | undefined
-> = {
-  readonly [FILE_REF_PROP]: string;
-  readonly [VAL_EXTENSION]: "file";
-  readonly metadata?: Metadata;
-};
-
-export function file<
-  Metadata extends { readonly [key: string]: JsonPrimitive }
->(ref: string, metadata: Metadata): FileSource<Metadata>;
-export function file(ref: string, metadata?: undefined): FileSource<undefined>;
-export function file<
-  Metadata extends { readonly [key: string]: JsonPrimitive } | undefined
->(ref: string, metadata?: Metadata): FileSource<Metadata> {
-  return {
-    [FILE_REF_PROP]: ref,
-    [VAL_EXTENSION]: "file",
-    metadata,
-  } as FileSource<Metadata>;
-}
-
-export function isFile(obj: unknown): obj is FileSource {
-  return (
-    typeof obj === "object" &&
-    obj !== null &&
-    VAL_EXTENSION in obj &&
-    obj[VAL_EXTENSION] === "file" &&
-    FILE_REF_PROP in obj &&
-    typeof obj[FILE_REF_PROP] === "string"
-  );
-}

package/src/source/future/i18n.ts

@@ -1,60 +0,0 @@
-import type { F } from "ts-toolbelt";
-import { SourcePrimitive, VAL_EXTENSION } from "..";
-import { FileSource } from "../file";
-
-/**
- * I18n sources cannot have nested remote sources.
- */
-export type I18nCompatibleSource =
-  | SourcePrimitive
-  | I18nObject
-  | I18nArray
-  | FileSource;
-export type I18nObject = { [key in string]: I18nCompatibleSource };
-export type I18nArray = readonly I18nCompatibleSource[];
-
-/**
- * An i18n source is a map of locales to sources.
- *
- * Its selector will default to the underlying source. It is possible to call `.all` on i18n sources, which returns an object with all the locales
- *
- */
-export type I18nSource<
-  Locales extends readonly string[],
-  T extends I18nCompatibleSource
-> = {
-  readonly [locale in Locales[number]]: T;
-} & {
-  readonly [VAL_EXTENSION]: "i18n";
-};
-
-export type I18n<Locales extends readonly string[]> = <
-  Src extends I18nCompatibleSource
->(source: {
-  [locale in Locales[number]]: Src;
-}) => I18nSource<Locales, Src>;
-export function i18n<Locales extends readonly string[]>(
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  locales: F.Narrow<Locales>
-): <Src extends I18nCompatibleSource>(source: {
-  [locale in Locales[number]]: Src;
-}) => I18nSource<Locales, Src> {
-  return (source) => {
-    return {
-      ...source,
-      [VAL_EXTENSION]: "i18n",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } as I18nSource<Locales, any>;
-  };
-}
-
-export function isI18n(
-  obj: unknown
-): obj is I18nSource<string[], I18nCompatibleSource> {
-  return (
-    typeof obj === "object" &&
-    obj !== null &&
-    VAL_EXTENSION in obj &&
-    obj[VAL_EXTENSION] === "i18n"
-  );
-}