@lytjs/core 6.5.0 → 6.6.0

package/dist/index.mjs

@@ -968,7 +968,10 @@ function createApp(rootComponent, rootProps = null, options) {
           if (typeof plugin === "function") {
             plugin(app, ...options2);
           } else if (plugin && typeof plugin.install === "function") {
-            plugin.install(app, ...options2);
+            plugin.install(
+              app,
+              ...options2
+            );
           }
         }
         installedPlugins.add(plugin);
@@ -1903,13 +1906,15 @@ var init_config_validator = __esm({
         if (value === void 0) {
           if (schema.required) {
             errors.push(this.createError(path, "required", "Value is required"));
-          } else if (schema.default !== void 0) ;
+          }
           return { valid: errors.length === 0, errors, errorCount: errors.length, warningCount: 0 };
         }
         if (schema.validate) {
           const result = schema.validate(value, context);
           if (!result.valid) {
-            errors.push(this.createError(path, "custom_error", result.message || "Custom validation failed"));
+            errors.push(
+              this.createError(path, "custom_error", result.message || "Custom validation failed")
+            );
           }
         }
         switch (schema.type) {
@@ -1923,7 +1928,9 @@ var init_config_validator = __esm({
             errors.push(...this.validateBoolean(value, schema, path));
             break;
           case "object":
-            errors.push(...this.validateObject(value, schema, path));
+            errors.push(
+              ...this.validateObject(value, schema, path)
+            );
             break;
           case "array":
             errors.push(...this.validateArray(value, schema, path));
@@ -1954,54 +1961,72 @@ var init_config_validator = __esm({
       validateString(value, schema, path) {
         const errors = [];
         if (typeof value !== "string") {
-          errors.push(this.createError(path, "type_error", `Expected string, got ${typeof value}`, "string", value));
+          errors.push(
+            this.createError(
+              path,
+              "type_error",
+              `Expected string, got ${typeof value}`,
+              "string",
+              value
+            )
+          );
           return errors;
         }
         const stringSchema = schema.string || {};
         if (stringSchema.minLength !== void 0 && value.length < stringSchema.minLength) {
-          errors.push(this.createError(
-            path,
-            "min_length",
-            `String must be at least ${stringSchema.minLength} characters`,
-            `minLength: ${stringSchema.minLength}`,
-            value.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "min_length",
+              `String must be at least ${stringSchema.minLength} characters`,
+              `minLength: ${stringSchema.minLength}`,
+              value.length
+            )
+          );
         }
         if (stringSchema.maxLength !== void 0 && value.length > stringSchema.maxLength) {
-          errors.push(this.createError(
-            path,
-            "max_length",
-            `String must be at most ${stringSchema.maxLength} characters`,
-            `maxLength: ${stringSchema.maxLength}`,
-            value.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "max_length",
+              `String must be at most ${stringSchema.maxLength} characters`,
+              `maxLength: ${stringSchema.maxLength}`,
+              value.length
+            )
+          );
         }
         if (stringSchema.pattern) {
           const pattern = typeof stringSchema.pattern === "string" ? new RegExp(stringSchema.pattern) : stringSchema.pattern;
           if (!pattern.test(value)) {
-            errors.push(this.createError(
-              path,
-              "pattern_mismatch",
-              `String does not match pattern: ${stringSchema.pattern}`,
-              String(stringSchema.pattern),
-              value
-            ));
+            errors.push(
+              this.createError(
+                path,
+                "pattern_mismatch",
+                `String does not match pattern: ${stringSchema.pattern}`,
+                String(stringSchema.pattern),
+                value
+              )
+            );
           }
         }
         if (stringSchema.format && this.isStringType(value)) {
           const formatError = this.validateFormat(value, stringSchema.format);
           if (formatError) {
-            errors.push(this.createError(path, "format_error", formatError, stringSchema.format, value));
+            errors.push(
+              this.createError(path, "format_error", formatError, stringSchema.format, value)
+            );
           }
         }
         if (stringSchema.enum && !stringSchema.enum.includes(value)) {
-          errors.push(this.createError(
-            path,
-            "enum_mismatch",
-            `Value must be one of: ${stringSchema.enum.join(", ")}`,
-            stringSchema.enum.join(" | "),
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "enum_mismatch",
+              `Value must be one of: ${stringSchema.enum.join(", ")}`,
+              stringSchema.enum.join(" | "),
+              value
+            )
+          );
         }
         return errors;
       }
@@ -2011,57 +2036,77 @@ var init_config_validator = __esm({
       validateNumber(value, schema, path) {
         const errors = [];
         if (typeof value !== "number" || Number.isNaN(value)) {
-          errors.push(this.createError(path, "type_error", `Expected number, got ${typeof value}`, "number", value));
+          errors.push(
+            this.createError(
+              path,
+              "type_error",
+              `Expected number, got ${typeof value}`,
+              "number",
+              value
+            )
+          );
           return errors;
         }
         const numberSchema = schema.number || {};
         if (numberSchema.integer && !Number.isInteger(value)) {
-          errors.push(this.createError(path, "type_error", "Value must be an integer", "integer", value));
+          errors.push(
+            this.createError(path, "type_error", "Value must be an integer", "integer", value)
+          );
         }
         if (numberSchema.minimum !== void 0 && value < numberSchema.minimum) {
-          errors.push(this.createError(
-            path,
-            "minimum",
-            `Value must be >= ${numberSchema.minimum}`,
-            `minimum: ${numberSchema.minimum}`,
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "minimum",
+              `Value must be >= ${numberSchema.minimum}`,
+              `minimum: ${numberSchema.minimum}`,
+              value
+            )
+          );
         }
         if (numberSchema.maximum !== void 0 && value > numberSchema.maximum) {
-          errors.push(this.createError(
-            path,
-            "maximum",
-            `Value must be <= ${numberSchema.maximum}`,
-            `maximum: ${numberSchema.maximum}`,
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "maximum",
+              `Value must be <= ${numberSchema.maximum}`,
+              `maximum: ${numberSchema.maximum}`,
+              value
+            )
+          );
         }
         if (numberSchema.exclusiveMinimum !== void 0 && value <= numberSchema.exclusiveMinimum) {
-          errors.push(this.createError(
-            path,
-            "minimum",
-            `Value must be > ${numberSchema.exclusiveMinimum}`,
-            `exclusiveMinimum: ${numberSchema.exclusiveMinimum}`,
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "minimum",
+              `Value must be > ${numberSchema.exclusiveMinimum}`,
+              `exclusiveMinimum: ${numberSchema.exclusiveMinimum}`,
+              value
+            )
+          );
         }
         if (numberSchema.exclusiveMaximum !== void 0 && value >= numberSchema.exclusiveMaximum) {
-          errors.push(this.createError(
-            path,
-            "maximum",
-            `Value must be < ${numberSchema.exclusiveMaximum}`,
-            `exclusiveMaximum: ${numberSchema.exclusiveMaximum}`,
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "maximum",
+              `Value must be < ${numberSchema.exclusiveMaximum}`,
+              `exclusiveMaximum: ${numberSchema.exclusiveMaximum}`,
+              value
+            )
+          );
         }
         if (numberSchema.enum && !numberSchema.enum.includes(value)) {
-          errors.push(this.createError(
-            path,
-            "enum_mismatch",
-            `Value must be one of: ${numberSchema.enum.join(", ")}`,
-            numberSchema.enum.join(" | "),
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "enum_mismatch",
+              `Value must be one of: ${numberSchema.enum.join(", ")}`,
+              numberSchema.enum.join(" | "),
+              value
+            )
+          );
         }
         return errors;
       }
@@ -2071,7 +2116,15 @@ var init_config_validator = __esm({
       validateBoolean(value, _schema, path) {
         const errors = [];
         if (typeof value !== "boolean") {
-          errors.push(this.createError(path, "type_error", `Expected boolean, got ${typeof value}`, "boolean", value));
+          errors.push(
+            this.createError(
+              path,
+              "type_error",
+              `Expected boolean, got ${typeof value}`,
+              "boolean",
+              value
+            )
+          );
         }
         return errors;
       }
@@ -2081,7 +2134,15 @@ var init_config_validator = __esm({
       validateObject(value, schema, path) {
         const errors = [];
         if (typeof value !== "object" || value === null || Array.isArray(value)) {
-          errors.push(this.createError(path, "type_error", `Expected object, got ${typeof value}`, "object", value));
+          errors.push(
+            this.createError(
+              path,
+              "type_error",
+              `Expected object, got ${typeof value}`,
+              "object",
+              value
+            )
+          );
           return errors;
         }
         const objectSchema = schema.object;
@@ -2089,22 +2150,26 @@ var init_config_validator = __esm({
         const obj = value;
         const keys = Object.keys(obj);
         if (objectSchema.maxProperties !== void 0 && keys.length > objectSchema.maxProperties) {
-          errors.push(this.createError(
-            path,
-            "max_items",
-            `Object must have at most ${objectSchema.maxProperties} properties`,
-            `maxProperties: ${objectSchema.maxProperties}`,
-            keys.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "max_items",
+              `Object must have at most ${objectSchema.maxProperties} properties`,
+              `maxProperties: ${objectSchema.maxProperties}`,
+              keys.length
+            )
+          );
         }
         if (objectSchema.minProperties !== void 0 && keys.length < objectSchema.minProperties) {
-          errors.push(this.createError(
-            path,
-            "min_items",
-            `Object must have at least ${objectSchema.minProperties} properties`,
-            `minProperties: ${objectSchema.minProperties}`,
-            keys.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "min_items",
+              `Object must have at least ${objectSchema.minProperties} properties`,
+              `minProperties: ${objectSchema.minProperties}`,
+              keys.length
+            )
+          );
         }
         for (const [key, propertySchema] of Object.entries(objectSchema.properties || {})) {
           const propertyPath = path ? `${path}.${key}` : key;
@@ -2131,13 +2196,15 @@ var init_config_validator = __esm({
                 }
               }
               if (!matchesPattern) {
-                errors.push(this.createError(
-                  `${path}.${key}`,
-                  "additional_properties",
-                  `Additional property "${key}" is not allowed`,
-                  key,
-                  key
-                ));
+                errors.push(
+                  this.createError(
+                    `${path}.${key}`,
+                    "additional_properties",
+                    `Additional property "${key}" is not allowed`,
+                    key,
+                    key
+                  )
+                );
               }
             }
           }
@@ -2150,27 +2217,33 @@ var init_config_validator = __esm({
       validateArray(value, schema, path) {
         const errors = [];
         if (!Array.isArray(value)) {
-          errors.push(this.createError(path, "type_error", `Expected array, got ${typeof value}`, "array", value));
+          errors.push(
+            this.createError(path, "type_error", `Expected array, got ${typeof value}`, "array", value)
+          );
           return errors;
         }
         const arraySchema = schema.array || {};
         if (arraySchema.minItems !== void 0 && value.length < arraySchema.minItems) {
-          errors.push(this.createError(
-            path,
-            "min_items",
-            `Array must have at least ${arraySchema.minItems} items`,
-            `minItems: ${arraySchema.minItems}`,
-            value.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "min_items",
+              `Array must have at least ${arraySchema.minItems} items`,
+              `minItems: ${arraySchema.minItems}`,
+              value.length
+            )
+          );
         }
         if (arraySchema.maxItems !== void 0 && value.length > arraySchema.maxItems) {
-          errors.push(this.createError(
-            path,
-            "max_items",
-            `Array must have at most ${arraySchema.maxItems} items`,
-            `maxItems: ${arraySchema.maxItems}`,
-            value.length
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "max_items",
+              `Array must have at most ${arraySchema.maxItems} items`,
+              `maxItems: ${arraySchema.maxItems}`,
+              value.length
+            )
+          );
         }
         if (arraySchema.uniqueItems) {
           const seen = /* @__PURE__ */ new Set();
@@ -2178,13 +2251,15 @@ var init_config_validator = __esm({
             const item = value[i];
             const key = JSON.stringify(item);
             if (seen.has(key)) {
-              errors.push(this.createError(
-                `${path}[${i}]`,
-                "unique_items",
-                `Duplicate item found at index ${i}`,
-                "uniqueItems",
-                item
-              ));
+              errors.push(
+                this.createError(
+                  `${path}[${i}]`,
+                  "unique_items",
+                  `Duplicate item found at index ${i}`,
+                  "uniqueItems",
+                  item
+                )
+              );
             }
             seen.add(key);
           }
@@ -2203,13 +2278,15 @@ var init_config_validator = __esm({
             errors.push(...itemReport.errors);
           }
           if (value.length !== arraySchema.tuple.length) {
-            errors.push(this.createError(
-              path,
-              "max_items",
-              `Tuple must have exactly ${arraySchema.tuple.length} items, got ${value.length}`,
-              `tuple length: ${arraySchema.tuple.length}`,
-              value.length
-            ));
+            errors.push(
+              this.createError(
+                path,
+                "max_items",
+                `Tuple must have exactly ${arraySchema.tuple.length} items, got ${value.length}`,
+                `tuple length: ${arraySchema.tuple.length}`,
+                value.length
+              )
+            );
           }
         }
         return errors;
@@ -2221,13 +2298,15 @@ var init_config_validator = __esm({
         const errors = [];
         const enumSchema = schema.enum;
         if (!enumSchema.values.includes(value)) {
-          errors.push(this.createError(
-            path,
-            "enum_mismatch",
-            `Value must be one of: ${enumSchema.values.map((v) => JSON.stringify(v)).join(", ")}`,
-            enumSchema.values.map((v) => JSON.stringify(v)).join(" | "),
-            value
-          ));
+          errors.push(
+            this.createError(
+              path,
+              "enum_mismatch",
+              `Value must be one of: ${enumSchema.values.map((v) => JSON.stringify(v)).join(", ")}`,
+              enumSchema.values.map((v) => JSON.stringify(v)).join(" | "),
+              value
+            )
+          );
         }
         return errors;
       }
@@ -2247,13 +2326,15 @@ var init_config_validator = __esm({
             }
           }
           if (!matched) {
-            errors.push(this.createError(
-              path,
-              "type_error",
-              "Value does not match any of the allowed types",
-              "union",
-              value
-            ));
+            errors.push(
+              this.createError(
+                path,
+                "type_error",
+                "Value does not match any of the allowed types",
+                "union",
+                value
+              )
+            );
           }
         }
         if (unionSchema.oneOf) {
@@ -2265,13 +2346,15 @@ var init_config_validator = __esm({
             }
           }
           if (matchCount !== 1) {
-            errors.push(this.createError(
-              path,
-              "type_error",
-              `Value must match exactly one of the allowed types, matched ${matchCount}`,
-              "oneOf",
-              value
-            ));
+            errors.push(
+              this.createError(
+                path,
+                "type_error",
+                `Value must match exactly one of the allowed types, matched ${matchCount}`,
+                "oneOf",
+                value
+              )
+            );
           }
         }
         return errors;
@@ -2427,20 +2510,32 @@ var init_config_transformer = __esm({
           }
         }
         if (schema.type === "object" && schema.object && typeof transformed === "object" && transformed !== null) {
-          const objectResult = this.transformObject(transformed, schema, path);
+          const objectResult = this.transformObject(
+            transformed,
+            schema,
+            path
+          );
           transformed = objectResult.value;
           errors.push(...objectResult.errors);
           warnings.push(...objectResult.warnings);
           transforms.push(...objectResult.transforms);
         } else if (schema.type === "array" && schema.array && Array.isArray(transformed)) {
-          const arrayResult = this.transformArray(transformed, schema, path);
+          const arrayResult = this.transformArray(
+            transformed,
+            schema,
+            path
+          );
           transformed = arrayResult.value;
           errors.push(...arrayResult.errors);
           warnings.push(...arrayResult.warnings);
           transforms.push(...arrayResult.transforms);
         }
         if (transformed !== void 0 && transformed !== null) {
-          const validationReport = this.validator.validate(transformed, schema, path);
+          const validationReport = this.validator.validate(
+            transformed,
+            schema,
+            path
+          );
           errors.push(...validationReport.errors);
         }
         return {
@@ -2555,7 +2650,10 @@ var init_config_transformer = __esm({
        * @returns 合并后的配置
        */
       merge(defaults, overrides, schema) {
-        const merged = this.deepMerge(defaults, overrides);
+        const merged = this.deepMerge(
+          defaults,
+          overrides
+        );
         return this.transform(merged, schema);
       }
       /**
@@ -2566,7 +2664,10 @@ var init_config_transformer = __esm({
         for (const [key, value] of Object.entries(source)) {
           if (value !== void 0) {
             if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
-              result[key] = this.deepMerge(result[key], value);
+              result[key] = this.deepMerge(
+                result[key],
+                value
+              );
             } else {
               result[key] = value;
             }
@@ -2588,7 +2689,11 @@ var init_config_transformer = __esm({
           if (key in configObj) {
             const propertySchema = schema.object?.properties?.[key];
             if (propertySchema) {
-              const propertyReport = this.transform(configObj[key], propertySchema, String(key));
+              const propertyReport = this.transform(
+                configObj[key],
+                propertySchema,
+                String(key)
+              );
               if (propertyReport.success) {
                 result[key] = propertyReport.config;
               }
@@ -3252,10 +3357,14 @@ function ErrorBoundary(props) {
   props.retryDelay ?? 1e3;
   const state = {
     resetKey: 0};
-  return createElement("error-boundary-wrapper", {
-    "data-error": "false",
-    key: `reset-${state.resetKey}`
-  }, null);
+  return createElement(
+    "error-boundary-wrapper",
+    {
+      "data-error": "false",
+      key: `reset-${state.resetKey}`
+    },
+    null
+  );
 }
 function useErrorHandler() {
   return (error3) => {