@valbuild/core 0.64.0 → 0.65.0

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

@@ -1,8 +1,8 @@
 export declare abstract class Expr {
-    readonly span?: [number, (number | undefined)?] | undefined;
+    readonly span?: [number, number?] | undefined;
     abstract type: "StringLiteral" | "Sym" | "StringTemplate" | "Call";
     abstract transpile(): string;
-    constructor(span?: [number, (number | undefined)?] | undefined);
+    constructor(span?: [number, number?] | undefined);
 }
 export declare class StringLiteral extends Expr {
     readonly value: string;

package/dist/declarations/src/expr/parser.d.ts

@@ -2,7 +2,7 @@ import { result } from "../fp/index.js";
 import { Expr } from "./expr.js";
 export declare class ParserError {
     readonly message: string;
-    readonly span?: [number, (number | undefined)?] | undefined;
-    constructor(message: string, span?: [number, (number | undefined)?] | undefined);
+    readonly span?: [number, number?] | undefined;
+    constructor(message: string, span?: [number, number?] | undefined);
 }
 export declare function parse(input: string): result.Result<Expr, ParserError>;

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

@@ -1,4 +1,4 @@
-export { initVal } from "./initVal.js";
+export { initVal, type ConfigDirectory } from "./initVal.js";
 export { modules, type ValModules } from "./modules.js";
 export type { InitVal, ValConfig, ValConstructor, ContentConstructor, } from "./initVal.js";
 export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/index.js";
@@ -21,7 +21,9 @@ export { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG } from "./source/file.js";
 export { VAL_EXTENSION, type SourceArray } from "./source/index.js";
 export { derefPatch } from "./patch/deref.js";
 export { type SelectorSource, type SelectorOf, GenericSelector, } from "./selector/index.js";
-import { getSource, resolvePath, splitModuleFilePathAndModulePath } from "./module.js";
+import { getSource, splitModulePath, splitModuleFilePath, resolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths } from "./module.js";
+declare const ModuleFilePathSep = "?p=";
+export { ModuleFilePathSep };
 import { getSchema } from "./selector/index.js";
 import { ModulePath, getValPath, isVal } from "./val/index.js";
 import { convertFileSource } from "./schema/file.js";
@@ -30,6 +32,8 @@ import { getVal } from "./future/fetchVal.js";
 import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
 import { getMimeType, mimeTypeToFileExt, filenameToMimeType } from "./mimeType/index.js";
+import { type ImageMetadata } from "./schema/image.js";
+import { type FileMetadata } from "./schema/file.js";
 export { type SerializedArraySchema, ArraySchema } from "./schema/array.js";
 export { type SerializedObjectSchema, ObjectSchema } from "./schema/object.js";
 export { type SerializedRecordSchema, RecordSchema } from "./schema/record.js";
@@ -41,7 +45,7 @@ export { type SerializedFileSchema, FileSchema } from "./schema/file.js";
 export { type SerializedDateSchema, DateSchema } from "./schema/date.js";
 export { type SerializedKeyOfSchema, KeyOfSchema } from "./schema/keyOf.js";
 export { type SerializedRichTextSchema, RichTextSchema, } from "./schema/richtext.js";
-export { type SerializedUnionSchema, UnionSchema } from "./schema/union.js";
+export { type SerializedUnionSchema, UnionSchema, type SerializedStringUnionSchema, type SerializedObjectUnionSchema, } from "./schema/union.js";
 export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js";
 export { deserializeSchema } from "./schema/deserialize.js";
 export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
@@ -57,6 +61,7 @@ declare const Internal: {
     getSource: typeof getSource;
     resolvePath: typeof resolvePath;
     splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
+    joinModuleFilePathAndModulePath: typeof joinModuleFilePathAndModulePath;
     isVal: typeof isVal;
     createValPathOfItem: typeof createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
@@ -69,7 +74,30 @@ declare const Internal: {
         [k: string]: string;
     };
     ModuleFilePathSep: string;
-    notFileOp: (op: Operation) => boolean;
+    notFileOp: (op: Operation) => op is {
+        op: "add";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    } | {
+        op: "remove";
+        path: import("./fp/array.js").NonEmptyArray<string>;
+    } | {
+        op: "replace";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    } | {
+        op: "move";
+        from: import("./fp/array.js").NonEmptyArray<string>;
+        path: string[];
+    } | {
+        op: "copy";
+        from: string[];
+        path: string[];
+    } | {
+        op: "test";
+        path: string[];
+        value: import("./patch/index.js").JSONValue;
+    };
     isFileOp: (op: Operation) => op is {
         op: "file";
         path: string[];
@@ -78,9 +106,14 @@ declare const Internal: {
     };
     createPatchJSONPath: (modulePath: ModulePath) => string;
     createPatchPath: (modulePath: ModulePath) => string[];
-    patchPathToModulePath: (patchPath: string[]) => ModulePath;
+    splitModulePath: typeof splitModulePath;
+    splitModuleFilePath: typeof splitModuleFilePath;
+    splitJoinedSourcePaths: typeof splitJoinedSourcePaths;
+    parentOfSourcePath: typeof parentOfSourcePath;
+    patchPathToModulePath: typeof patchPathToModulePath;
     VAL_ENABLE_COOKIE_NAME: "val_enable";
     VAL_STATE_COOKIE: "val_state";
     VAL_SESSION_COOKIE: "val_session";
+    createFilename: (data: string | null, filename: string | null, metadata: FileMetadata | ImageMetadata | undefined, sha256: string) => string | null;
 };
 export { Internal };

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

@@ -27,60 +27,30 @@ export type InitSchema = {
     readonly date: typeof date;
 };
 export declare function initSchema(): {
-    string: <T extends string>(options?: Record<string, never> | undefined) => import("./schema/string.js").StringSchema<T>;
+    string: <T extends string>(options?: Record<string, never>) => import("./schema/string.js").StringSchema<T>;
     boolean: () => import("./schema/index.js").Schema<boolean>;
     array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<import("./schema/index.js").SelectorOfSchema<S>[]>;
     object: <Props extends {
         [key: string]: import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>;
     } & {
-        valPath?: undefined;
-        val?: undefined;
-        _type?: undefined;
-        _ref?: undefined;
-        andThen?: undefined;
-        assert?: undefined;
-        fold?: undefined;
+        valPath?: never;
+        val?: never;
+        _type?: never;
+        _ref?: never;
+        andThen?: never;
+        assert?: never;
+        fold?: never;
     }>(schema: Props) => import("./schema/index.js").Schema<{ [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
     number: (options?: {
-        max?: number | undefined;
-        min?: number | undefined;
-    } | undefined) => import("./schema/index.js").Schema<number>;
-    union: <Key extends string | import("./schema/index.js").Schema<string>, T_1 extends import("./schema/index.js").Schema<Key extends string ? {
-        [x: string]: import("./source/index.js").Source;
-    } & {
-        fold?: undefined;
-        assert?: undefined;
-        andThen?: undefined;
-        _ref?: undefined;
-        _type?: undefined;
-        val?: undefined;
-        valPath?: undefined;
-    } & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T_1) => import("./schema/index.js").Schema<T_1 extends import("./schema/index.js").Schema<infer S_1 extends import("./selector/index.js").SelectorSource>[] ? S_1 extends import("./selector/index.js").SelectorSource ? S_1 | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
-    richtext: <O extends Partial<{
-        style: Partial<{
-            bold: boolean;
-            italic: boolean;
-            lineThrough: boolean;
-        }>;
-        block: Partial<{
-            h1: boolean;
-            h2: boolean;
-            h3: boolean;
-            h4: boolean;
-            h5: boolean;
-            h6: boolean;
-            ul: boolean;
-            ol: boolean;
-        }>;
-        inline: Partial<{
-            a: boolean;
-            img: boolean;
-        }>;
-    }>>(options?: O | undefined) => import("./schema/index.js").Schema<import("./index.js").RichTextSource<O>>;
-    image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").ImageSource>;
-    literal: <T_2 extends string>(value: T_2) => import("./schema/literal.js").LiteralSchema<T_2>;
-    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject | import("./source/index.js").SourceArray, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly import("./source/index.js").Source[] ? number : S_2 extends import("./source/index.js").SourceObject ? string extends keyof S_2 ? import("./schema/string.js").RawString : keyof S_2 : S_2 extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
-    record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S_3>>>;
-    file: (options?: import("./schema/file.js").FileOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
-    date: (options?: Record<string, never> | undefined) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
+        max?: number;
+        min?: number;
+    }) => import("./schema/index.js").Schema<number>;
+    union: <Key extends string | import("./schema/index.js").Schema<string>, T extends import("./schema/index.js").Schema<Key extends string ? import("./source/index.js").SourceObject & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => import("./schema/index.js").Schema<T extends import("./schema/index.js").Schema<infer S extends import("./selector/index.js").SelectorSource>[] ? S extends import("./selector/index.js").SelectorSource ? S | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
+    richtext: <O extends import("./index.js").RichTextOptions>(options?: O) => import("./schema/index.js").Schema<import("./index.js").RichTextSource<O>>;
+    image: (options?: import("./schema/image.js").ImageOptions) => import("./schema/index.js").Schema<import("./index.js").ImageSource>;
+    literal: <T extends string>(value: T) => import("./schema/literal.js").LiteralSchema<T>;
+    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S extends import("./source/index.js").Source, undefined> ? S extends readonly import("./source/index.js").Source[] ? number : S extends import("./source/index.js").SourceObject ? string extends keyof S ? import("./schema/string.js").RawString : keyof S : S extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
+    record: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S>>>;
+    file: (options?: import("./schema/file.js").FileOptions) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
+    date: (options?: Record<string, never>) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
 };

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

@@ -1,14 +1,14 @@
 import { define } from "./module.js";
 import { InitSchema } from "./initSchema.js";
 import { getValPath as getPath } from "./val/index.js";
-import { file } from "./source/file.js";
+import { initFile } from "./source/file.js";
 import { richtext } from "./source/richtext.js";
 import { link } from "./source/link.js";
 export type ContentConstructor = {
     define: typeof define;
-    file: typeof file;
+    file: ReturnType<typeof initFile>;
     rt: {
-        image: typeof file;
+        image: ReturnType<typeof initFile>;
         link: typeof link;
     };
     richtext: typeof richtext;
@@ -16,11 +16,16 @@ export type ContentConstructor = {
 export type ValConstructor = {
     unstable_getPath: typeof getPath;
 };
+export type ConfigDirectory = `/public/${string}`;
 export type ValConfig = {
     project?: string;
     root?: string;
+    files?: {
+        directory: ConfigDirectory;
+    };
     gitCommit?: string;
     gitBranch?: string;
+    defaultTheme?: "dark" | "light";
 };
 export type InitVal = {
     c: ContentConstructor;

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

@@ -21,14 +21,18 @@ export declare function define<T extends Schema<SelectorSource>>(id: string, //
 schema: T, source: ReplaceRawStringWithString<SelectorOfSchema<T>>): ValModule<SelectorOfSchema<T>>;
 export declare function getSource(valModule: ValModule<SelectorSource>): Source;
 export declare function splitModuleFilePathAndModulePath(path: SourcePath): [moduleId: ModuleFilePath, path: ModulePath];
-export declare const ModuleFilePathSep = "?p=";
+export declare function joinModuleFilePathAndModulePath(moduleFilePath: ModuleFilePath, modulePath: ModulePath): SourcePath;
 export declare function getSourceAtPath(modulePath: ModulePath, valModule: ValModule<SelectorSource> | Source): any;
 export declare function resolvePath<Src extends ValModule<SelectorSource> | Source, Sch extends Schema<SelectorSource> | SerializedSchema>(path: ModulePath, valModule: Src, schema: Sch): {
     path: SourcePath;
     schema: Sch;
     source: Src;
 };
-export declare function parsePath(input: ModulePath): string[];
+export declare function splitModuleFilePath(input: ModuleFilePath): string[];
+export declare function splitModulePath(input: ModulePath): string[];
+export declare function splitJoinedSourcePaths(input: string): SourcePath[];
+export declare function parentOfSourcePath(sourcePath: SourcePath): SourcePath;
+export declare function patchPathToModulePath(patchPath: string[]): ModulePath;
 export type SerializedModule = {
     source: Json;
     schema: SerializedSchema;

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

@@ -12,7 +12,6 @@ export type SerializedFileSchema = {
     opt: boolean;
 };
 export type FileMetadata = {
-    sha256: string;
     mimeType?: string;
 };
 export declare class FileSchema<Src extends FileSource<FileMetadata | undefined> | null> extends Schema<Src> {

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

@@ -17,7 +17,6 @@ export type SerializedImageSchema = {
 export type ImageMetadata = {
     width: number;
     height: number;
-    sha256: string;
     mimeType: string;
     hotspot?: {
         x: number;

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

@@ -1,7 +1,7 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ValModuleBrand } from "../module.js";
 import { GenericSelector } from "../selector/index.js";
-import { Source, SourceArray, SourceObject } from "../source/index.js";
+import { Source, SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 import { RawString } from "./string.js";
@@ -10,10 +10,10 @@ export type SerializedKeyOfSchema = {
     path: SourcePath;
     schema: SerializedSchema;
     opt: boolean;
-    values: "string" | "number" | string[];
+    values: "string" | string[];
 };
-type KeyOfSelector<Sel extends GenericSelector<SourceArray | SourceObject>> = Sel extends GenericSelector<infer S> ? S extends readonly Source[] ? number : S extends SourceObject ? string extends keyof S ? RawString : keyof S : S extends Record<string, Source> ? RawString : never : never;
-export declare class KeyOfSchema<Sel extends GenericSelector<SourceArray | SourceObject>, Src extends KeyOfSelector<Sel> | null> extends Schema<Src> {
+type KeyOfSelector<Sel extends GenericSelector<SourceObject>> = Sel extends GenericSelector<infer S> ? S extends readonly Source[] ? number : S extends SourceObject ? string extends keyof S ? RawString : keyof S : S extends Record<string, Source> ? RawString : never : never;
+export declare class KeyOfSchema<Sel extends GenericSelector<SourceObject>, Src extends KeyOfSelector<Sel> | null> extends Schema<Src> {
     readonly schema?: SerializedSchema | undefined;
     readonly sourcePath?: SourcePath | undefined;
     readonly opt: boolean;
@@ -23,5 +23,5 @@ export declare class KeyOfSchema<Sel extends GenericSelector<SourceArray | Sourc
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const keyOf: <Src extends GenericSelector<SourceObject | SourceArray, undefined> & ValModuleBrand>(valModule: Src) => Schema<KeyOfSelector<Src>>;
+export declare const keyOf: <Src extends GenericSelector<SourceObject> & ValModuleBrand>(valModule: Src) => Schema<KeyOfSelector<Src>>;
 export {};

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

@@ -17,24 +17,4 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const richtext: <O extends Partial<{
-    style: Partial<{
-        bold: boolean;
-        italic: boolean;
-        lineThrough: boolean;
-    }>;
-    block: Partial<{
-        h1: boolean;
-        h2: boolean;
-        h3: boolean;
-        h4: boolean;
-        h5: boolean;
-        h6: boolean;
-        ul: boolean;
-        ol: boolean;
-    }>;
-    inline: Partial<{
-        a: boolean;
-        img: boolean;
-    }>;
-}>>(options?: O | undefined) => Schema<RichTextSource<O>>;
+export declare const richtext: <O extends RichTextOptions>(options?: O) => Schema<RichTextSource<O>>;

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

@@ -2,11 +2,20 @@ import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
+import { SerializedLiteralSchema } from "./literal.js";
+import { SerializedObjectSchema } from "./object.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
-export type SerializedUnionSchema = {
+export type SerializedUnionSchema = SerializedStringUnionSchema | SerializedObjectUnionSchema;
+export type SerializedStringUnionSchema = {
     type: "union";
-    key: string | SerializedSchema;
-    items: SerializedSchema[];
+    key: SerializedLiteralSchema;
+    items: SerializedLiteralSchema[];
+    opt: boolean;
+};
+export type SerializedObjectUnionSchema = {
+    type: "union";
+    key: string;
+    items: SerializedObjectSchema[];
     opt: boolean;
 };
 type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
@@ -24,15 +33,5 @@ export declare class UnionSchema<Key extends string | Schema<string>, T extends
     serialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean);
 }
-export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? {
-    [x: string]: import("../source/index.js").Source;
-} & {
-    fold?: undefined;
-    assert?: undefined;
-    andThen?: undefined;
-    _ref?: undefined;
-    _type?: undefined;
-    val?: undefined;
-    valPath?: undefined;
-} & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
+export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
 export {};

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

@@ -1,4 +1,5 @@
 import { VAL_EXTENSION } from "./index.js";
+import { ValConfig } from "../initVal.js";
 import { Json } from "../Json.js";
 export declare const FILE_REF_PROP: "_ref";
 export declare const FILE_REF_SUBTYPE_TAG: "_tag";
@@ -18,8 +19,10 @@ export type FileSource<Metadata extends FileMetadata | undefined = FileMetadata
     readonly metadata?: Metadata;
     readonly patch_id?: string;
 };
-export declare function file<Metadata extends {
-    readonly [key: string]: Json;
-}>(ref: `/public/${string}`, metadata: Metadata): FileSource<Metadata>;
-export declare function file(ref: `/public/${string}`, metadata?: undefined): FileSource<undefined>;
+export declare const initFile: (config?: ValConfig) => {
+    <Metadata extends {
+        readonly [key: string]: Json;
+    }>(ref: `${`/public/${string}`}/${string}`, metadata: Metadata): FileSource<Metadata>;
+    (ref: `${`/public/${string}`}/${string}`, metadata?: undefined): FileSource<undefined>;
+};
 export declare function isFile(obj: unknown): obj is FileSource;