@valbuild/core 0.40.0 → 0.41.0

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

@@ -10,13 +10,13 @@ export declare class ValApi {
     host: string;
     constructor(host: string);
     getDisableUrl(redirectTo: string): string;
-    getEditUrl(): string;
     getLoginUrl(redirectTo: string): string;
     getEnableUrl(redirectTo: string): string;
     getPatches({ patchIds, headers, }: {
         patchIds?: string[];
         headers?: Record<string, string> | undefined;
     }): Promise<result.Result<ApiGetPatchResponse, FetchError>>;
+    getEditUrl(): string;
     postPatches(moduleId: ModuleId, patches: PatchJSON, headers?: Record<string, string> | undefined): Promise<result.Result<ApiPostPatchResponse, FetchError>>;
     getSession(): Promise<result.Result<{
         mode: "proxy" | "local";

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

@@ -35,6 +35,8 @@ export type { SerializedNumberSchema } from "./schema/number.js";
 export type { SerializedBooleanSchema } from "./schema/boolean.js";
 export type { SerializedImageSchema } from "./schema/image.js";
 export type { SerializedRichTextSchema } from "./schema/richtext.js";
+export type { SerializedUnionSchema } from "./schema/union.js";
+export type { SerializedLiteralSchema } from "./schema/literal.js";
 export type ApiTreeResponse = {
     git: {
         commit?: string;
@@ -79,7 +81,7 @@ declare const Internal: {
     splitModuleIdAndModulePath: typeof splitModuleIdAndModulePath;
     isVal: typeof isVal;
     createValPathOfItem: typeof createValPathOfItem;
-    getSHA256Hash: (bits: Uint8Array) => Promise<string>;
+    getSHA256Hash: (bits: Uint8Array) => string;
     createPatchJSONPath: (modulePath: ModulePath) => string;
     VAL_ENABLE_COOKIE_NAME: "val_enable";
     VAL_STATE_COOKIE: "val_state";

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

@@ -36,7 +36,7 @@ export declare function initSchema(): {
         max?: number | undefined;
         min?: number | undefined;
     } | undefined) => import("./schema/index.js").Schema<number>;
-    union: <Key extends string, T_1 extends import("./schema/index.js").Schema<{
+    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;
@@ -46,7 +46,7 @@ export declare function initSchema(): {
         _type?: undefined;
         val?: undefined;
         valPath?: undefined;
-    } & { [k in Key]: string; }>[]>(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 : never : never>;
+    } & { [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 import("./index.js").RichTextOptions>(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").FileSource<import("./schema/image.js").ImageMetadata>>;
     literal: <T_2 extends string>(value: T_2) => import("./schema/index.js").Schema<T_2>;

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

@@ -14,7 +14,7 @@ type ValConstructor = {
 export type ValConfig = {
     gitCommit?: string;
     gitBranch?: string;
-    valConfigPath: string;
+    valConfigPath?: string;
 };
 export type InitVal = {
     val: ValConstructor;

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

@@ -8,6 +8,7 @@ export type SerializedKeyOfSchema = {
     type: "keyOf";
     selector: SourcePath;
     opt: boolean;
+    values: "string" | "number" | string[];
 };
 type KeyOfSelector<Sel extends GenericSelector<SourceArray | SourceObject>> = Sel extends GenericSelector<infer S> ? S extends readonly any[] ? number : S extends SourceObject ? keyof S : S extends Record<string, any> ? string : never : never;
 export declare class KeyOfSchema<Sel extends GenericSelector<SourceArray | SourceObject>> extends Schema<KeyOfSelector<Sel>> {

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

@@ -5,16 +5,16 @@ import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedUnionSchema = {
     type: "union";
-    key: string;
+    key?: string;
     items: SerializedSchema[];
     opt: boolean;
 };
-type SourceOf<Key extends string, T extends Schema<SourceObject & {
+type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? 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 & {
+} : Key extends Schema<string> ? string : unknown>[]> = T extends Schema<infer S>[] ? S extends SelectorSource ? S | (Key extends Schema<infer K> ? K : never) : never : never;
+export declare class UnionSchema<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
     [k in Key]: string;
-}>[]> extends Schema<SourceOf<Key, T>> {
+} : Key extends Schema<string> ? string : unknown>[]> extends Schema<SourceOf<Key, T>> {
     readonly key: Key;
     readonly items: T;
     readonly opt: boolean;
@@ -24,7 +24,7 @@ export declare class UnionSchema<Key extends string, T extends Schema<SourceObje
     serialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean);
 }
-export declare const union: <Key extends string, T extends Schema<{
+export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? {
     [x: string]: import("../source/index.js").Source;
 } & {
     fold?: undefined;
@@ -34,5 +34,5 @@ export declare const union: <Key extends string, T extends Schema<{
     _type?: undefined;
     val?: undefined;
     valPath?: undefined;
-} & { [k in Key]: string; }>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
+} & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
 export {};

package/dist/{ops-ce47df64.esm.js → ops-266faf09.esm.js}

@@ -342,24 +342,34 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   _createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      throw new Error("Method not implemented.");
+      // TODO:
+      return false;
     }
   }, {
     key: "assert",
     value: function assert(src) {
-      throw new Error("Method not implemented.");
+      return true;
     }
   }, {
     key: "optional",
     value: function optional() {
-      throw new Error("Method not implemented.");
+      return new UnionSchema(this.key, this.items, true);
     }
   }, {
     key: "serialize",
     value: function serialize() {
+      if (typeof this.key === "string") {
+        return {
+          type: "union",
+          key: this.key,
+          items: this.items.map(function (o) {
+            return o.serialize();
+          }),
+          opt: this.opt
+        };
+      }
       return {
         type: "union",
-        key: this.key,
         items: this.items.map(function (o) {
           return o.serialize();
         }),
@@ -645,6 +655,22 @@ function resolvePath(path, valModule, schema) {
         };
       } else if (isUnionSchema(resolvedSchema)) {
         var _key = resolvedSchema.key;
+        if (!_key) {
+          return {
+            v: {
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
         var keyValue = resolvedSource[_key];
         if (!keyValue) {
           throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));

package/dist/{ops-6489efeb.cjs.prod.js → ops-d88e99cd.cjs.prod.js}

@@ -344,24 +344,34 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      throw new Error("Method not implemented.");
+      // TODO:
+      return false;
     }
   }, {
     key: "assert",
     value: function assert(src) {
-      throw new Error("Method not implemented.");
+      return true;
     }
   }, {
     key: "optional",
     value: function optional() {
-      throw new Error("Method not implemented.");
+      return new UnionSchema(this.key, this.items, true);
     }
   }, {
     key: "serialize",
     value: function serialize() {
+      if (typeof this.key === "string") {
+        return {
+          type: "union",
+          key: this.key,
+          items: this.items.map(function (o) {
+            return o.serialize();
+          }),
+          opt: this.opt
+        };
+      }
       return {
         type: "union",
-        key: this.key,
         items: this.items.map(function (o) {
           return o.serialize();
         }),
@@ -647,6 +657,22 @@ function resolvePath(path, valModule, schema) {
         };
       } else if (isUnionSchema(resolvedSchema)) {
         var _key = resolvedSchema.key;
+        if (!_key) {
+          return {
+            v: {
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
         var keyValue = resolvedSource[_key];
         if (!keyValue) {
           throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));

package/dist/{ops-bec039cc.cjs.dev.js → ops-e02ab215.cjs.dev.js}

@@ -344,24 +344,34 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   index._createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
-      throw new Error("Method not implemented.");
+      // TODO:
+      return false;
     }
   }, {
     key: "assert",
     value: function assert(src) {
-      throw new Error("Method not implemented.");
+      return true;
     }
   }, {
     key: "optional",
     value: function optional() {
-      throw new Error("Method not implemented.");
+      return new UnionSchema(this.key, this.items, true);
     }
   }, {
     key: "serialize",
     value: function serialize() {
+      if (typeof this.key === "string") {
+        return {
+          type: "union",
+          key: this.key,
+          items: this.items.map(function (o) {
+            return o.serialize();
+          }),
+          opt: this.opt
+        };
+      }
       return {
         type: "union",
-        key: this.key,
         items: this.items.map(function (o) {
           return o.serialize();
         }),
@@ -647,6 +657,22 @@ function resolvePath(path, valModule, schema) {
         };
       } else if (isUnionSchema(resolvedSchema)) {
         var _key = resolvedSchema.key;
+        if (!_key) {
+          return {
+            v: {
+              path: origParts.map(function (p) {
+                if (!Number.isNaN(Number(p))) {
+                  return p;
+                } else {
+                  return JSON.stringify(p);
+                }
+              }).join("."),
+              // TODO: create a function generate path from parts (not sure if this always works)
+              schema: resolvedSchema,
+              source: resolvedSource
+            }
+          };
+        }
         var keyValue = resolvedSource[_key];
         if (!keyValue) {
           throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));