@valbuild/core 0.60.27 → 0.62.0

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

@@ -1,7 +1,7 @@
-import { ApiCommitResponse, ApiGetPatchResponse, ApiPostValidationErrorResponse, ApiPostPatchResponse, ApiPostValidationResponse, ApiTreeResponse, Json } from "./index.js";
+import { ApiCommitResponse, ApiGetPatchResponse, ApiPostValidationErrorResponse, ApiPostValidationResponse, ApiTreeResponse, Json, ApiSchemaResponse } from "./index.js";
 import { result } from "./fp/index.js";
 import { Patch } from "./patch/index.js";
-import { ModuleId, PatchId } from "./val/index.js";
+import { ModuleFilePath, PatchId } from "./val/index.js";
 type FetchError = {
     message: string;
     details?: unknown;
@@ -13,13 +13,9 @@ export declare class ValApi {
     getDisableUrl(redirectTo: string): string;
     getLoginUrl(redirectTo: string): string;
     getEnableUrl(redirectTo: string): string;
-    getPatches({ patchIds, headers, }: {
-        patchIds?: string[];
-        headers?: Record<string, string> | undefined;
-    }): Promise<result.Result<ApiGetPatchResponse, FetchError>>;
+    getPatches(): Promise<result.Result<ApiGetPatchResponse, FetchError>>;
     deletePatches(ids: string[], headers?: Record<string, string>): Promise<result.Result<Json, FetchError>>;
     getEditUrl(): string;
-    postPatches(moduleId: ModuleId, patches: Patch, headers?: Record<string, string> | undefined): Promise<result.Result<ApiPostPatchResponse, FetchError>>;
     getSession(): Promise<result.Result<{
         mode: "proxy" | "local";
         member_role: "owner" | "developer" | "editor";
@@ -27,19 +23,26 @@ export declare class ValApi {
         mode: "proxy" | "local";
         member_role: "owner" | "developer" | "editor";
     }>>;
-    getTree({ patch, includeSchema, includeSource, treePath, headers, }: {
-        patch?: boolean;
-        includeSchema?: boolean;
-        includeSource?: boolean;
+    getSchema({ headers }: {
+        headers?: Record<string, string> | undefined;
+    }): Promise<result.Result<ApiSchemaResponse, FetchError>>;
+    putTree({ treePath, patchIds, addPatch, validateAll, validateSource, validateBinaryFiles, headers, }: {
         treePath?: string;
+        patchIds?: PatchId[];
+        addPatch?: {
+            path: ModuleFilePath;
+            patch: Patch;
+        };
+        validateAll?: boolean;
+        validateSource?: boolean;
+        validateBinaryFiles?: boolean;
         headers?: Record<string, string> | undefined;
     }): Promise<result.Result<ApiTreeResponse, FetchError>>;
-    postCommit({ patches, headers, }: {
-        patches?: Record<ModuleId, PatchId[]>;
-        headers?: Record<string, string> | undefined;
+    postSave({ patchIds, }: {
+        patchIds: PatchId[];
     }): Promise<result.Result<ApiCommitResponse, FetchError | ApiPostValidationErrorResponse>>;
     postValidate({ patches, headers, }: {
-        patches?: Record<ModuleId, PatchId[]>;
+        patches?: Record<ModuleFilePath, PatchId[]>;
         headers?: Record<string, string> | undefined;
     }): Promise<result.Result<ApiPostValidationResponse | ApiPostValidationErrorResponse, FetchError>>;
 }

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

@@ -1,4 +1,5 @@
 export { initVal } 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";
 export type { ImageMetadata } from "./schema/image.js";
@@ -11,26 +12,26 @@ export type { RawString } from "./schema/string.js";
 export type { ImageSource } from "./source/image.js";
 export { RT_IMAGE_TAG } from "./source/richtext.js";
 export type { AnyRichTextOptions, Bold, Classes, HeadingNode, ImageNode, Italic, LineThrough, ListItemNode, LinkNode, OrderedListNode, ParagraphNode, BrNode, RichText, RichTextNode, RichTextOptions, RichTextSource, RootNode, SpanNode, UnorderedListNode, } from "./source/richtext.js";
-export { type Val, type SerializedVal, type ModuleId, type PatchId, type ModulePath, type SourcePath, type JsonOfSource, } from "./val/index.js";
+export { type Val, type SerializedVal, type ModuleFilePath, type PatchId, type ModulePath, type SourcePath, type JsonOfSource, } from "./val/index.js";
 export type { Json, JsonPrimitive, JsonArray, JsonObject } from "./Json.js";
 export type { ValidationError, ValidationErrors, } from "./schema/validation/ValidationError.js";
-import type { ValidationErrors } from "./schema/validation/ValidationError.js";
+import type { ValidationError, ValidationErrors } from "./schema/validation/ValidationError.js";
 export type { ValidationFix } from "./schema/validation/ValidationFix.js";
 export * as expr from "./expr/index.js";
 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, splitModuleIdAndModulePath } from "./module.js";
+import { getSource, resolvePath, splitModuleFilePathAndModulePath } from "./module.js";
 import { getSchema } from "./selector/index.js";
-import { ModuleId, ModulePath, PatchId, getValPath, isVal } from "./val/index.js";
+import { ModuleFilePath, ModulePath, PatchId, SourcePath, getValPath, isVal } from "./val/index.js";
 import { convertFileSource } from "./schema/file.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
 import { getVal } from "./future/fetchVal.js";
 import type { Json } from "./Json.js";
-import { SerializedSchema } from "./schema/index.js";
-import { Operation, Patch } from "./patch/index.js";
+import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
+import { SerializedSchema } from "./schema/index.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";
@@ -44,55 +45,48 @@ export { type SerializedUnionSchema, UnionSchema } from "./schema/union.js";
 export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js";
 export { deserializeSchema } from "./schema/deserialize.js";
 export { ValApi } from "./ValApi.js";
-export type ApiCommitResponse = {
-    validationErrors: false;
-    modules: Record<ModuleId, {
-        patches: {
-            applied: PatchId[];
-        };
-    }>;
-    git: {
-        commit?: string;
-        branch?: string;
-    };
+export type ApiCommitResponse = {};
+export type ApiSchemaResponse = {
+    schemaSha: string;
+    schemas: Record<ModuleFilePath, SerializedSchema>;
 };
 export type ApiTreeResponse = {
-    git: {
-        commit?: string;
-        branch?: string;
-    };
-    modules: Record<ModuleId, {
-        schema?: SerializedSchema;
+    schemaSha: string;
+    fatalErrors?: ({
+        message: string;
+        type: "invalid-module-file-path";
+        actualModuleFilePath: string;
+        expectedModuleFilePath: string;
+    } | {
+        message: string;
+        stack?: string;
+        type?: undefined;
+    })[];
+    modules: Record<ModuleFilePath, {
+        source: Json;
         patches?: {
             applied: PatchId[];
-            failed?: PatchId[];
-        };
-        source?: Json;
-        errors?: false | {
-            invalidModuleId?: ModuleId;
-            validation?: ValidationErrors;
-            fatal?: {
+            skipped?: PatchId[];
+            errors?: Record<PatchId, {
                 message: string;
-                stack?: string;
-                type?: string;
-            }[];
+            }>;
         };
+        validationErrors?: Record<SourcePath, ValidationError[]>;
     }>;
 };
-export type ApiGetPatchResponse = Record<ModuleId, {
-    patch: Patch;
+export type ApiGetPatchResponse = Record<ModuleFilePath, {
     patch_id: PatchId;
     created_at: string;
-    commit_sha?: string;
+    applied_at_base_sha: string | null;
     author?: string;
 }[]>;
 export type ApiDeletePatchResponse = PatchId[];
-export type ApiPostPatchResponse = Record<ModuleId, {
+export type ApiPostPatchResponse = Record<ModuleFilePath, {
     patch_id: PatchId;
 }>;
 export type ApiPostValidationResponse = {
     validationErrors: false;
-    modules: Record<ModuleId, {
+    modules: Record<ModuleFilePath, {
         patches: {
             applied: PatchId[];
         };
@@ -101,16 +95,16 @@ export type ApiPostValidationResponse = {
 export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
 export type FatalErrorType = (typeof FATAL_ERROR_TYPES)[number];
 export type ApiPostValidationErrorResponse = {
-    modules: Record<ModuleId, {
+    modules: Record<ModuleFilePath, {
         patches: {
             applied: PatchId[];
             failed?: PatchId[];
         };
     }>;
-    validationErrors: Record<ModuleId, {
+    validationErrors: Record<ModuleFilePath, {
         source?: Json;
         errors: {
-            invalidModuleId?: ModuleId;
+            invalidModulePath?: ModuleFilePath;
             validation?: ValidationErrors;
             fatal?: {
                 message: string;
@@ -130,11 +124,12 @@ declare const Internal: {
     getVal: typeof getVal;
     getSource: typeof getSource;
     resolvePath: typeof resolvePath;
-    splitModuleIdAndModulePath: typeof splitModuleIdAndModulePath;
+    splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
     isVal: typeof isVal;
     createValPathOfItem: typeof createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
     initSchema: typeof initSchema;
+    ModuleFilePathSep: string;
     notFileOp: (op: Operation) => boolean;
     isFileOp: (op: Operation) => op is {
         op: "file";

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

@@ -17,7 +17,7 @@ export type ValConstructor = {
     unstable_getPath: typeof getPath;
 };
 export type ValConfig = {
-    remote?: string;
+    project?: string;
     root?: string;
     gitCommit?: string;
     gitBranch?: string;

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

@@ -1,7 +1,7 @@
 import { Schema, SelectorOfSchema, SerializedSchema } from "./schema/index.js";
 import { GenericSelector, SelectorOf, SelectorSource } from "./selector/index.js";
 import { Source } from "./source/index.js";
-import { ModuleId, ModulePath, SourcePath } from "./val/index.js";
+import { ModuleFilePath, ModulePath, SourcePath } from "./val/index.js";
 import { Json } from "./Json.js";
 import { RawString } from "./schema/string.js";
 import { ImageSelector } from "./selector/image.js";
@@ -20,7 +20,8 @@ type ReplaceRawStringWithString<T extends SelectorSource> = SelectorSource exten
 export declare function define<T extends Schema<SelectorSource>>(id: string, // TODO: `/${string}`
 schema: T, source: ReplaceRawStringWithString<SelectorOfSchema<T>>): ValModule<SelectorOfSchema<T>>;
 export declare function getSource(valModule: ValModule<SelectorSource>): Source;
-export declare function splitModuleIdAndModulePath(path: SourcePath): [moduleId: ModuleId, path: ModulePath];
+export declare function splitModuleFilePathAndModulePath(path: SourcePath): [moduleId: ModuleFilePath, path: ModulePath];
+export declare const ModuleFilePathSep = "?p=";
 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;

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

@@ -0,0 +1,30 @@
+import { ValConfig } from "./initVal.js";
+import { ValModule } from "./module.js";
+import { SelectorSource } from "./selector/index.js";
+export type ValModules = {
+    config: ValConfig;
+    modules: {
+        /**
+         * A module definition defined as a function that returns a promise that resolves to the module.
+         *
+         * @example
+         * { def: () => import('./module.val') }
+         */
+        def: () => Promise<{
+            default: ValModule<SelectorSource>;
+        }>;
+    }[];
+};
+/**
+ * Define the set of modules that can be edited using the Val UI.
+ *
+ * @example
+ * import { modules } from "@valbuild/next";
+ * import { config } from "./val.config";
+ *
+ * export default modules(config, [
+ *  { def: () => import("./app/page.val.ts") },
+ *  { def: () => import("./app/another/page.val.ts") },
+ * ]);
+ */
+export declare function modules(config: ValConfig, modules: ValModules["modules"]): ValModules;

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

@@ -16,6 +16,7 @@ export type FileSource<Metadata extends FileMetadata | undefined = FileMetadata
     readonly [VAL_EXTENSION]: "file";
     readonly [FILE_REF_SUBTYPE_TAG]?: string;
     readonly metadata?: Metadata;
+    readonly patch_id?: string;
 };
 export declare function file<Metadata extends {
     readonly [key: string]: Json;

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

@@ -42,13 +42,13 @@ export type ModulePath = string & {
     [brand]: "ModulePath";
 };
 /**
- * The id of the module.
+ * The path of the module.
  *
  * @example
- * '/app/blogs' // the /app/blogs module
+ * '/app/blogs.val.ts'
  */
-export type ModuleId = string & {
-    [brand]: "ModuleId";
+export type ModuleFilePath = string & {
+    [brand]: "ModuleFilePath";
 };
 export type PatchId = string & {
     [brand]: "PatchId";