@valbuild/core 0.12.0

package/dist/declarations/src/patch/operation.d.ts

@@ -0,0 +1,59 @@
+import { array } from "../fp";
+import type { JSONValue } from "./ops";
+/**
+ * Raw JSON patch operation.
+ */
+export type OperationJSON = {
+    op: "add";
+    path: string;
+    value: JSONValue;
+} | {
+    op: "remove";
+    path: string;
+} | {
+    op: "replace";
+    path: string;
+    value: JSONValue;
+} | {
+    op: "move";
+    from: string;
+    path: string;
+} | {
+    op: "copy";
+    from: string;
+    path: string;
+} | {
+    op: "test";
+    path: string;
+    value: JSONValue;
+};
+/**
+ * Parsed form of JSON patch operation.
+ */
+export type Operation = {
+    op: "add";
+    path: string[];
+    value: JSONValue;
+} | {
+    op: "remove";
+    path: array.NonEmptyArray<string>;
+} | {
+    op: "replace";
+    path: string[];
+    value: JSONValue;
+} | {
+    op: "move";
+    /**
+     * Must be non-root and not a proper prefix of "path".
+     */
+    from: array.NonEmptyArray<string>;
+    path: string[];
+} | {
+    op: "copy";
+    from: string[];
+    path: string[];
+} | {
+    op: "test";
+    path: string[];
+    value: JSONValue;
+};

package/dist/declarations/src/patch/ops.d.ts

@@ -0,0 +1,40 @@
+import { result, array } from "../fp";
+export declare class PatchError {
+    message: string;
+    constructor(message: string);
+}
+export type ReadonlyJSONValue = string | number | boolean | null | readonly ReadonlyJSONValue[] | {
+    readonly [key: string]: ReadonlyJSONValue;
+};
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+type ToMutableJSONArray<T extends readonly ReadonlyJSONValue[]> = {
+    [P in keyof T]: ToMutable<T[P]>;
+};
+export type ToMutable<T extends ReadonlyJSONValue> = JSONValue extends T ? JSONValue : T extends readonly ReadonlyJSONValue[] ? ToMutableJSONArray<T> : T extends {
+    readonly [key: string]: ReadonlyJSONValue;
+} ? {
+    -readonly [P in keyof T]: ToMutable<T[P]>;
+} : T;
+type ToReadonlyJSONArray<T extends readonly ReadonlyJSONValue[]> = {
+    readonly [P in keyof T]: ToReadonly<T[P]>;
+};
+export type ToReadonly<T extends ReadonlyJSONValue> = JSONValue extends T ? ReadonlyJSONValue : T extends readonly ReadonlyJSONValue[] ? ToReadonlyJSONArray<T> : T extends {
+    readonly [key: string]: ReadonlyJSONValue;
+} ? {
+    readonly [P in keyof T]: ToReadonly<T[P]>;
+} : T;
+/**
+ * NOTE: MAY mutate the input document.
+ */
+export interface Ops<T, E> {
+    add(document: T, path: string[], value: JSONValue): result.Result<T, E | PatchError>;
+    remove(document: T, path: array.NonEmptyArray<string>): result.Result<T, E | PatchError>;
+    replace(document: T, path: string[], value: JSONValue): result.Result<T, E | PatchError>;
+    move(document: T, from: array.NonEmptyArray<string>, path: string[]): result.Result<T, E | PatchError>;
+    copy(document: T, from: string[], path: string[]): result.Result<T, E | PatchError>;
+    test(document: T, path: string[], value: JSONValue): result.Result<boolean, E | PatchError>;
+    get(document: T, path: string[]): result.Result<JSONValue, E | PatchError>;
+}
+export {};

package/dist/declarations/src/patch/parse.d.ts

@@ -0,0 +1,19 @@
+import { array, result } from "../fp";
+import { Operation, OperationJSON } from "./operation";
+import { Patch, PatchJSON } from "./patch";
+export declare function parseJSONPointer(pointer: string): result.Result<string[], string>;
+export declare function formatJSONPointerReferenceToken(key: string): string;
+export declare function formatJSONPointer(path: string[]): string;
+/**
+ * A signifies an issue that makes a PatchJSON or an OperationJSON invalid.
+ * Unlike PatchError, a StaticPatchIssue indicates an issue with the patch
+ * document itself; it is independent of any document which the patch or
+ * might be applied to.
+ */
+export type StaticPatchIssue = {
+    path: string[];
+    message: string;
+};
+export declare function prefixIssuePath(prefix: string, { path, message }: StaticPatchIssue): StaticPatchIssue;
+export declare function parseOperation(operation: OperationJSON): result.Result<Operation, array.NonEmptyArray<StaticPatchIssue>>;
+export declare function parsePatch(patch: PatchJSON): result.Result<Patch, array.NonEmptyArray<StaticPatchIssue>>;

package/dist/declarations/src/patch/patch.d.ts

@@ -0,0 +1,6 @@
+import { result } from "../fp";
+import { Ops, PatchError } from "./ops";
+import { Operation, OperationJSON } from "./operation";
+export type Patch = Operation[];
+export type PatchJSON = OperationJSON[];
+export declare function applyPatch<T, E>(document: T, ops: Ops<T, E>, patch: Operation[]): result.Result<T, E | PatchError>;

package/dist/declarations/src/patch/util.d.ts

@@ -0,0 +1,6 @@
+import { array, result } from "../fp";
+import { PatchError, ReadonlyJSONValue, ToMutable } from "./ops";
+export declare function isNotRoot(path: string[]): path is array.NonEmptyArray<string>;
+export declare function deepEqual(a: ReadonlyJSONValue, b: ReadonlyJSONValue): boolean;
+export declare function deepClone<T extends ReadonlyJSONValue>(value: T): ToMutable<T>;
+export declare function parseAndValidateArrayIndex(value: string): result.Result<number, PatchError>;

package/dist/declarations/src/schema/array.d.ts

@@ -0,0 +1,18 @@
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourcePath } from "../val";
+export type SerializedArraySchema = {
+    type: "array";
+    item: SerializedSchema;
+    opt: boolean;
+};
+export declare class ArraySchema<T extends Schema<SelectorSource>> extends Schema<SchemaTypeOf<T>[]> {
+    readonly item: T;
+    readonly opt: boolean;
+    constructor(item: T, opt?: boolean);
+    validate(src: SchemaTypeOf<T>[]): false | Record<SourcePath, string[]>;
+    match(src: SchemaTypeOf<T>[]): boolean;
+    optional(): Schema<SchemaTypeOf<T>[] | null>;
+    serialize(): SerializedArraySchema;
+}
+export declare const array: <S extends Schema<SelectorSource>>(schema: S) => Schema<SchemaTypeOf<S>[]>;

package/dist/declarations/src/schema/boolean.d.ts

@@ -0,0 +1,15 @@
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+export type SerializedBooleanSchema = {
+    type: "boolean";
+    opt: boolean;
+};
+export declare class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
+    readonly opt: boolean;
+    constructor(opt?: boolean);
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<Src | null>;
+    serialize(): SerializedSchema;
+}
+export declare const boolean: () => Schema<boolean>;

package/dist/declarations/src/schema/i18n.d.ts

@@ -0,0 +1,21 @@
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { I18nCompatibleSource, I18nSource } from "../source/i18n";
+import { SourcePath } from "../val";
+export type SerializedI18nSchema = {
+    type: "i18n";
+    locales: readonly string[];
+    item: SerializedSchema;
+    opt: boolean;
+};
+export declare class I18nSchema<Locales extends readonly string[]> extends Schema<I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>> {
+    readonly locales: Locales;
+    readonly item: Schema<SchemaTypeOf<Schema<I18nCompatibleSource>>>;
+    readonly opt: boolean;
+    constructor(locales: Locales, item: Schema<SchemaTypeOf<Schema<I18nCompatibleSource>>>, opt?: boolean);
+    validate(src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): false | Record<SourcePath, string[]>;
+    match(src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): boolean;
+    optional(): Schema<I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>> | null>;
+    serialize(): SerializedSchema;
+}
+export type I18n<Locales extends readonly string[]> = <S extends Schema<I18nCompatibleSource>>(schema: S) => Schema<I18nSource<Locales, SchemaTypeOf<S>>>;
+export declare const i18n: <Locales extends readonly string[]>(locales: Locales) => <S extends Schema<I18nCompatibleSource>>(schema: S) => Schema<I18nSource<Locales, SchemaTypeOf<S>>>;

package/dist/declarations/src/schema/image.d.ts

@@ -0,0 +1,32 @@
+import { Schema, SerializedSchema } from ".";
+import { FileSource } from "../source/file";
+import { SourcePath } from "../val";
+export type ImageOptions = {
+    ext: ["jpg"] | ["webp"];
+    directory?: string;
+    prefix?: string;
+};
+export type SerializedImageSchema = {
+    type: "image";
+    options?: ImageOptions;
+    opt: boolean;
+};
+export type ImageMetadata = {
+    width: number;
+    height: number;
+    sha256: string;
+} | undefined;
+export declare class ImageSchema<Src extends FileSource<ImageMetadata> | null> extends Schema<Src> {
+    readonly options?: ImageOptions | undefined;
+    readonly opt: boolean;
+    constructor(options?: ImageOptions | undefined, opt?: boolean);
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<Src | null>;
+    serialize(): SerializedSchema;
+}
+export declare const image: (options?: ImageOptions) => Schema<FileSource<ImageMetadata>>;
+export declare const convertImageSource: (src: FileSource<ImageMetadata>) => {
+    url: string;
+    metadata?: ImageMetadata;
+};

package/dist/declarations/src/schema/index.d.ts

@@ -0,0 +1,23 @@
+import { SelectorSource } from "../selector";
+import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+import { SourcePath } from "../val";
+import { SerializedArraySchema } from "./array";
+import { SerializedBooleanSchema } from "./boolean";
+import { SerializedI18nSchema } from "./i18n";
+import { SerializedImageSchema } from "./image";
+import { SerializedLiteralSchema } from "./literal";
+import { SerializedNumberSchema } from "./number";
+import { SerializedObjectSchema } from "./object";
+import { SerializedOneOfSchema } from "./oneOf";
+import { SerializedRichTextSchema } from "./richtext";
+import { SerializedStringSchema } from "./string";
+import { SerializedUnionSchema } from "./union";
+export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedOneOfSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedImageSchema | SerializedI18nSchema;
+export declare abstract class Schema<Src extends SelectorSource> {
+    abstract validate(src: Src): false | Record<SourcePath, string[]>;
+    abstract match(src: Src): boolean;
+    abstract optional(): Schema<Src | null>;
+    abstract serialize(): SerializedSchema;
+    remote(): Src extends RemoteCompatibleSource ? Schema<RemoteSource<Src>> : never;
+}
+export type SchemaTypeOf<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;

package/dist/declarations/src/schema/literal.d.ts

@@ -0,0 +1,17 @@
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+export type SerializedLiteralSchema = {
+    type: "literal";
+    value: string;
+    opt: boolean;
+};
+export declare class LiteralSchema<Src extends string | null> extends Schema<Src> {
+    readonly value: string;
+    readonly opt: boolean;
+    constructor(value: string, opt?: boolean);
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<Src | null>;
+    serialize(): SerializedSchema;
+}
+export declare const literal: <T extends string>(value: T) => Schema<T>;

package/dist/declarations/src/schema/number.d.ts

@@ -0,0 +1,22 @@
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+type NumberOptions = {
+    max?: number;
+    min?: number;
+};
+export type SerializedNumberSchema = {
+    type: "number";
+    options?: NumberOptions;
+    opt: boolean;
+};
+export declare class NumberSchema<Src extends number | null> extends Schema<Src> {
+    readonly options?: NumberOptions | undefined;
+    readonly opt: boolean;
+    constructor(options?: NumberOptions | undefined, opt?: boolean);
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<Src | null>;
+    serialize(): SerializedSchema;
+}
+export declare const number: (options?: NumberOptions) => Schema<number>;
+export {};

package/dist/declarations/src/schema/object.d.ts

@@ -0,0 +1,25 @@
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourcePath } from "../val";
+export type SerializedObjectSchema = {
+    type: "object";
+    items: Record<string, SerializedSchema>;
+    opt: boolean;
+};
+type ObjectSchemaProps = {
+    [key: string]: Schema<SelectorSource>;
+};
+type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
+    [key in keyof Props]: SchemaTypeOf<Props[key]>;
+};
+export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<ObjectSchemaSrcOf<Props>> {
+    readonly items: Props;
+    readonly opt: boolean;
+    constructor(items: Props, opt?: boolean);
+    validate(src: ObjectSchemaSrcOf<Props>): false | Record<SourcePath, string[]>;
+    match(src: ObjectSchemaSrcOf<Props>): boolean;
+    optional(): Schema<ObjectSchemaSrcOf<Props> | null>;
+    serialize(): SerializedSchema;
+}
+export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SchemaTypeOf<Props[key]>; }>;
+export {};

package/dist/declarations/src/schema/oneOf.d.ts

@@ -0,0 +1,22 @@
+import { Schema, SerializedSchema } from ".";
+import { ValModuleBrand } from "../module";
+import { GenericSelector } from "../selector";
+import { Source, SourceArray } from "../source";
+import { SourcePath } from "../val";
+export type SerializedOneOfSchema = {
+    type: "oneOf";
+    selector: SourcePath;
+    opt: boolean;
+};
+type OneOfSelector<Sel extends GenericSelector<SourceArray>> = Sel extends GenericSelector<infer S> ? S extends (infer IS)[] ? IS extends Source ? GenericSelector<IS> : never : never : never;
+export declare class OneOfSchema<Sel extends GenericSelector<SourceArray>> extends Schema<OneOfSelector<Sel>> {
+    readonly selector: Sel;
+    readonly opt: boolean;
+    constructor(selector: Sel, opt?: boolean);
+    validate(src: OneOfSelector<Sel>): false | Record<SourcePath, string[]>;
+    match(src: OneOfSelector<Sel>): boolean;
+    optional(): Schema<OneOfSelector<Sel> | null>;
+    serialize(): SerializedSchema;
+}
+export declare const oneOf: <Src extends GenericSelector<SourceArray, undefined> & ValModuleBrand>(valModule: Src) => Schema<OneOfSelector<Src>>;
+export {};

package/dist/declarations/src/schema/richtext.d.ts

@@ -0,0 +1,76 @@
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+export type SerializedRichTextSchema = {
+    type: "richtext";
+    opt: boolean;
+};
+type Node = {
+    version: 1;
+};
+type NodeType = Node & {
+    format: FormatType;
+    direction: DirectionType;
+    indent: number;
+};
+type FormatType = "left" | "start" | "center" | "right" | "end" | "justify" | "";
+type DirectionType = "ltr" | "rtl" | null;
+export type TextNode = Node & {
+    format: FormatType | number;
+    detail: number;
+    mode: "normal" | "code" | "quote";
+    style: string;
+    text: string;
+    type: "text";
+    direction?: DirectionType;
+    indent?: number;
+};
+export type ImageNode = Node & {
+    altText: string;
+    height: number;
+    width: number;
+    maxWidth: number;
+    src: string;
+    type: "image";
+};
+export type ParagraphNode<VN = TextNode> = NodeType & {
+    children: (TextNode | VN)[];
+    type: "paragraph";
+};
+export type HeadingNode<HT extends HeadingTags = HeadingTags> = NodeType & {
+    children: TextNode[];
+    type: "heading";
+    tag: HT;
+};
+export type ListItemNode<VN = TextNode> = NodeType & {
+    children: (TextNode | VN)[];
+    type: "listitem";
+    value: number;
+    checked?: boolean;
+};
+export type ListNode<VN = TextNode> = NodeType & {
+    children: ListItemNode<VN>[];
+    type: "list";
+    tag: "ol" | "ul";
+    listType: "number" | "bullet" | "check";
+    start?: number;
+};
+type HeadingTags = "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+export type RootNode<HT extends HeadingTags, VN> = Node & {
+    children: (HeadingNode<HT> | ParagraphNode<VN> | ListNode<VN>)[];
+    type: "root";
+    format: FormatType;
+    direction: DirectionType;
+    indent: number;
+};
+type ValNode = ImageNode;
+export type RichText<HT extends HeadingTags = HeadingTags, VN extends TextNode | ValNode = TextNode> = RootNode<HT, VN>;
+export declare class RichTextSchema<Src extends RichText | null> extends Schema<Src> {
+    readonly opt: boolean;
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<RichText<HeadingTags, TextNode> | null>;
+    serialize(): SerializedSchema;
+    constructor(opt?: boolean);
+}
+export declare const richtext: () => Schema<RichText>;
+export {};

package/dist/declarations/src/schema/string.d.ts

@@ -0,0 +1,22 @@
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+type StringOptions = {
+    maxLength?: number;
+    minLength?: number;
+};
+export type SerializedStringSchema = {
+    type: "string";
+    options?: StringOptions;
+    opt: boolean;
+};
+export declare class StringSchema<Src extends string | null> extends Schema<Src> {
+    readonly options?: StringOptions | undefined;
+    readonly opt: boolean;
+    constructor(options?: StringOptions | undefined, opt?: boolean);
+    validate(src: Src): false | Record<SourcePath, string[]>;
+    match(src: Src): boolean;
+    optional(): Schema<Src | null>;
+    serialize(): SerializedSchema;
+}
+export declare const string: <T extends string>(options?: StringOptions) => Schema<T>;
+export {};

package/dist/declarations/src/schema/union.d.ts

@@ -0,0 +1,36 @@
+import { Schema, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourceObject } from "../source";
+import { SourcePath } from "../val";
+export type SerializedUnionSchema = {
+    type: "union";
+    key: string;
+    items: SerializedSchema[];
+    opt: boolean;
+};
+type SourceOf<Key extends string, T extends Schema<SourceObject & {
+    [k in Key]: string;
+}>[]> = T extends Schema<infer S>[] ? S extends SelectorSource ? S : never : never;
+export declare class UnionSchema<Key extends string, T extends Schema<SourceObject & {
+    [k in Key]: string;
+}>[]> extends Schema<SourceOf<Key, T>> {
+    readonly key: Key;
+    readonly items: T;
+    readonly opt: boolean;
+    validate(src: SourceOf<Key, T>): false | Record<SourcePath, string[]>;
+    match(src: SourceOf<Key, T>): boolean;
+    optional(): Schema<SourceOf<Key, T> | null>;
+    serialize(): SerializedSchema;
+    constructor(key: Key, items: T, opt?: boolean);
+}
+export declare const union: <Key extends string, T extends Schema<{
+    [x: string]: import("../source").Source;
+} & {
+    fold?: undefined;
+    andThen?: undefined;
+    _ref?: undefined;
+    _type?: undefined;
+    val?: undefined;
+    valPath?: undefined;
+} & { [k in Key]: string; }>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
+export {};

package/dist/declarations/src/selector/SelectorProxy.d.ts

@@ -0,0 +1,7 @@
+import { GenericSelector } from ".";
+import { Source } from "../source";
+import { SourcePath } from "../val";
+export declare function isSelector(source: any): source is GenericSelector<Source>;
+export declare function newSelectorProxy(source: any, path?: SourcePath, moduleSchema?: any): any;
+export declare function createValPathOfItem(arrayPath: SourcePath | undefined, prop: string | number | symbol): SourcePath | undefined;
+export declare function selectorToVal(s: any): any;

package/dist/declarations/src/selector/array.d.ts

@@ -0,0 +1,17 @@
+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
+] ? U extends Source[] ? Selector<U> : never : never;
+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[]>;
+    andThen<U extends SelectorSource>(f: (v: UnknownSelector<NonNullable<T>>) => U): SelectorOf<U | T>;
+};

package/dist/declarations/src/selector/boolean.d.ts

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

package/dist/declarations/src/selector/file.d.ts

@@ -0,0 +1,9 @@
+import { Selector as UnknownSelector, GenericSelector, SelectorOf, SelectorSource } from ".";
+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/dist/declarations/src/selector/i18n.d.ts

@@ -0,0 +1,11 @@
+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>;
+    };
+};
+export {};

package/dist/declarations/src/selector/index.d.ts

@@ -0,0 +1,81 @@
+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 { A } from "ts-toolbelt";
+import { I18nSource, I18nCompatibleSource } from "../source/i18n";
+import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+import { FileSource } from "../source/file";
+/**
+ * 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 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 | GenericSelector<Source>;
+/**
+ * @internal
+ */
+export declare const GetSchema: unique symbol;
+/**
+/**
+ * @internal
+ */
+export declare const Path: unique symbol;
+/**
+ * @internal
+ */
+export declare const SourceOrExpr: unique symbol;
+/**
+ * @internal
+ */
+export declare const ValError: unique symbol;
+export declare 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);
+    assert<U extends Source, E extends Source = null>(schema: Schema<U>, other?: () => E): SelectorOf<U | E>;
+}
+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)[] ? 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 ? S extends Source ? Selector<S> : GenericSelector<Source, "Could not determine selector of source"> : GenericSelector<Source, "Could not determine source">;
+export declare function getSchema(selector: Selector<Source>): Schema<SelectorSource> | undefined;

package/dist/declarations/src/selector/number.d.ts

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

package/dist/declarations/src/selector/object.d.ts

@@ -0,0 +1,10 @@
+import { Selector as UnknownSelector, GenericSelector, SelectorOf, SelectorSource } from ".";
+import { SourceObject } from "../source";
+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/dist/declarations/src/selector/primitive.d.ts

@@ -0,0 +1,9 @@
+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;
+export {};

package/dist/declarations/src/selector/remote.d.ts

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