@stsdti/funky-ui-kit 1.0.3 → 1.1.0

package/dist/funky-ui-kit.es.js

@@ -5932,7 +5932,7 @@ let tuple = {
     return ValidationError.formatError(mixed.notType, params);
   }
 };
-var locale$2 = Object.assign(/* @__PURE__ */ Object.create(null), {
+Object.assign(/* @__PURE__ */ Object.create(null), {
   mixed,
   string,
   number,
@@ -5982,9 +5982,6 @@ const prefixes = {
   context: "$",
   value: "."
 };
-function create$9(key, options) {
-  return new Reference(key, options);
-}
 class Reference {
   constructor(key, options = {}) {
     this.key = void 0;
@@ -7243,9 +7240,6 @@ class NumberSchema extends Schema {
 create$5.prototype = NumberSchema.prototype;
 let invalidDate = /* @__PURE__ */ new Date("");
 let isDate$3 = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
-function create$4() {
-  return new DateSchema();
-}
 class DateSchema extends Schema {
   constructor() {
     super({
@@ -7305,8 +7299,6 @@ class DateSchema extends Schema {
   }
 }
 DateSchema.INVALID_DATE = invalidDate;
-create$4.prototype = DateSchema.prototype;
-create$4.INVALID_DATE = invalidDate;
 function sortFields(fields, excludedEdges = []) {
   let edges = [];
   let nodes = /* @__PURE__ */ new Set();
@@ -7851,233 +7843,6 @@ class ArraySchema extends Schema {
   }
 }
 create$2.prototype = ArraySchema.prototype;
-function create$1(schemas) {
-  return new TupleSchema(schemas);
-}
-class TupleSchema extends Schema {
-  constructor(schemas) {
-    super({
-      type: "tuple",
-      spec: {
-        types: schemas
-      },
-      check(v) {
-        const types = this.spec.types;
-        return Array.isArray(v) && v.length === types.length;
-      }
-    });
-    this.withMutation(() => {
-      this.typeError(tuple.notType);
-    });
-  }
-  _cast(inputValue, options) {
-    const {
-      types
-    } = this.spec;
-    const value = super._cast(inputValue, options);
-    if (!this._typeCheck(value)) {
-      return value;
-    }
-    let isChanged = false;
-    const castArray = types.map((type, idx) => {
-      const castElement = type.cast(value[idx], Object.assign({}, options, {
-        path: `${options.path || ""}[${idx}]`
-      }));
-      if (castElement !== value[idx]) isChanged = true;
-      return castElement;
-    });
-    return isChanged ? castArray : value;
-  }
-  _validate(_value, options = {}, panic, next2) {
-    let itemTypes = this.spec.types;
-    super._validate(_value, options, panic, (tupleErrors, value) => {
-      var _options$originalValu2;
-      if (!this._typeCheck(value)) {
-        next2(tupleErrors, value);
-        return;
-      }
-      let tests = [];
-      for (let [index, itemSchema] of itemTypes.entries()) {
-        var _options$originalValu;
-        tests[index] = itemSchema.asNestedTest({
-          options,
-          index,
-          parent: value,
-          parentPath: options.path,
-          originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value
-        });
-      }
-      this.runTests({
-        value,
-        tests,
-        originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,
-        options
-      }, panic, (innerTypeErrors) => next2(innerTypeErrors.concat(tupleErrors), value));
-    });
-  }
-  describe(options) {
-    const next2 = (options ? this.resolve(options) : this).clone();
-    const base = super.describe(options);
-    base.innerType = next2.spec.types.map((schema, index) => {
-      var _innerOptions;
-      let innerOptions = options;
-      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
-        innerOptions = Object.assign({}, innerOptions, {
-          parent: innerOptions.value,
-          value: innerOptions.value[index]
-        });
-      }
-      return schema.describe(innerOptions);
-    });
-    return base;
-  }
-}
-create$1.prototype = TupleSchema.prototype;
-function create$a(builder) {
-  return new Lazy(builder);
-}
-function catchValidationError(fn7) {
-  try {
-    return fn7();
-  } catch (err) {
-    if (ValidationError.isError(err)) return Promise.reject(err);
-    throw err;
-  }
-}
-class Lazy {
-  constructor(builder) {
-    this.type = "lazy";
-    this.__isYupSchema__ = true;
-    this.spec = void 0;
-    this._resolve = (value, options = {}) => {
-      let schema = this.builder(value, options);
-      if (!isSchema(schema)) throw new TypeError("lazy() functions must return a valid schema");
-      if (this.spec.optional) schema = schema.optional();
-      return schema.resolve(options);
-    };
-    this.builder = builder;
-    this.spec = {
-      meta: void 0,
-      optional: false
-    };
-  }
-  clone(spec) {
-    const next2 = new Lazy(this.builder);
-    next2.spec = Object.assign({}, this.spec, spec);
-    return next2;
-  }
-  optionality(optional) {
-    const next2 = this.clone({
-      optional
-    });
-    return next2;
-  }
-  optional() {
-    return this.optionality(true);
-  }
-  resolve(options) {
-    return this._resolve(options.value, options);
-  }
-  cast(value, options) {
-    return this._resolve(value, options).cast(value, options);
-  }
-  asNestedTest(config) {
-    let {
-      key,
-      index,
-      parent,
-      options
-    } = config;
-    let value = parent[index != null ? index : key];
-    return this._resolve(value, Object.assign({}, options, {
-      value,
-      parent
-    })).asNestedTest(config);
-  }
-  validate(value, options) {
-    return catchValidationError(() => this._resolve(value, options).validate(value, options));
-  }
-  validateSync(value, options) {
-    return this._resolve(value, options).validateSync(value, options);
-  }
-  validateAt(path, value, options) {
-    return catchValidationError(() => this._resolve(value, options).validateAt(path, value, options));
-  }
-  validateSyncAt(path, value, options) {
-    return this._resolve(value, options).validateSyncAt(path, value, options);
-  }
-  isValid(value, options) {
-    try {
-      return this._resolve(value, options).isValid(value, options);
-    } catch (err) {
-      if (ValidationError.isError(err)) {
-        return Promise.resolve(false);
-      }
-      throw err;
-    }
-  }
-  isValidSync(value, options) {
-    return this._resolve(value, options).isValidSync(value, options);
-  }
-  describe(options) {
-    return options ? this.resolve(options).describe(options) : {
-      type: "lazy",
-      meta: this.spec.meta,
-      label: void 0
-    };
-  }
-  meta(...args) {
-    if (args.length === 0) return this.spec.meta;
-    let next2 = this.clone();
-    next2.spec.meta = Object.assign(next2.spec.meta || {}, args[0]);
-    return next2;
-  }
-}
-function setLocale(custom) {
-  Object.keys(custom).forEach((type) => {
-    Object.keys(custom[type]).forEach((method) => {
-      locale$2[type][method] = custom[type][method];
-    });
-  });
-}
-function addMethod(schemaType, name, fn7) {
-  if (!schemaType || !isSchema(schemaType.prototype)) throw new TypeError("You must provide a yup schema constructor function");
-  if (typeof name !== "string") throw new TypeError("A Method name must be provided");
-  if (typeof fn7 !== "function") throw new TypeError("Method function must be provided");
-  schemaType.prototype[name] = fn7;
-}
-const yup = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ArraySchema,
-  BooleanSchema,
-  DateSchema,
-  LazySchema: Lazy,
-  MixedSchema,
-  NumberSchema,
-  ObjectSchema,
-  Schema,
-  StringSchema,
-  TupleSchema,
-  ValidationError,
-  addMethod,
-  array: create$2,
-  bool: create$7,
-  boolean: create$7,
-  date: create$4,
-  defaultLocale: locale$2,
-  getIn,
-  isSchema,
-  lazy: create$a,
-  mixed: create$8,
-  number: create$5,
-  object: create$3,
-  printValue,
-  reach,
-  ref: create$9,
-  setLocale,
-  string: create$6,
-  tuple: create$1
-}, Symbol.toStringTag, { value: "Module" }));
 function generateComputedChildren(localVariable, newComputedSubKeys = []) {
   const subItems = newComputedSubKeys.reduce((result, key) => {
     if (!key) {
@@ -8123,8 +7888,12 @@ function generateComputedParent(data) {
 }
 const isFieldRequired = (schema, fieldName) => {
   var _a3;
-  const fieldSchema = (_a3 = schema.fields) == null ? void 0 : _a3[fieldName];
-  return (fieldSchema == null ? void 0 : fieldSchema.spec.optional) === false;
+  try {
+    const fieldSchema = reach(schema, fieldName);
+    return ((_a3 = fieldSchema == null ? void 0 : fieldSchema.spec) == null ? void 0 : _a3.optional) === false;
+  } catch {
+    return false;
+  }
 };
 function getStyleFromObject(style) {
   return Object.keys(style).filter((key) => style[key]).join("; ");
@@ -20195,6 +19964,7 @@ __publicField(ResponseUtils, "STATUS_CODES", {
   STATUS_CODE_UNAUTHORIZED: 401,
   STATUS_CODE_FORBIDDEN: 403,
   STATUS_CODE_CONFLICT: 409,
+  STATUS_CODE_PRECONDITION_REQUIRED: 428,
   STATUS_CODE_UNPROCESSABLE_ENTITY: 422,
   STATUS_CODE_SERVER_ERROR: 500
 });
@@ -85026,9 +84796,13 @@ function useFormValidation(config) {
     element == null ? void 0 : element.scrollIntoView({ behavior: "smooth" });
   };
   const isFieldRequired2 = (fieldName) => {
-    var _a3, _b2;
-    const fieldSchema = (_b2 = (_a3 = toValue$2(schema)) == null ? void 0 : _a3.fields) == null ? void 0 : _b2[fieldName];
-    return (fieldSchema == null ? void 0 : fieldSchema.spec.optional) === false;
+    var _a3;
+    try {
+      const fieldSchema = reach(toValue$2(schema), fieldName);
+      return ((_a3 = fieldSchema == null ? void 0 : fieldSchema.spec) == null ? void 0 : _a3.optional) === false;
+    } catch {
+      return false;
+    }
   };
   const externalContext = {
     errors,
@@ -85496,27 +85270,155 @@ const getComponentType = (node) => {
       return node.component;
   }
 };
-const buildYupSchema = (validationConfig) => {
-  if (!validationConfig) return create$3();
-  const shape = {};
-  for (const [field, rules] of Object.entries(validationConfig)) {
-    if (!yup[rules.type]) continue;
-    let validator2 = yup[rules.type || "string"]();
-    if (rules.required) {
-      validator2 = validator2.required(rules.requiredMessage || void 0);
+const parseRuleString = (ruleString) => {
+  if (!ruleString || typeof ruleString !== "string") return [];
+  return ruleString.split("|").map((rule) => {
+    const [name, ...rest] = rule.split(":");
+    const params = rest.join(":");
+    return { name: name.trim(), params: params || null };
+  });
+};
+const buildFieldValidator = (rules) => {
+  const typeRule = rules.find(
+    (r) => ["string", "number", "integer", "boolean", "array", "mixed"].includes(r.name)
+  );
+  const typeName = (typeRule == null ? void 0 : typeRule.name) || "mixed";
+  let validator2;
+  switch (typeName) {
+    case "string":
+      validator2 = create$6();
+      break;
+    case "number":
+      validator2 = create$5();
+      break;
+    case "integer":
+      validator2 = create$5().integer();
+      break;
+    case "boolean":
+      validator2 = create$7();
+      break;
+    case "array":
+      validator2 = create$2();
+      break;
+    default:
+      validator2 = create$8();
+  }
+  for (const rule of rules) {
+    switch (rule.name) {
+      // Type rules already handled above
+      case "string":
+      case "number":
+      case "integer":
+      case "boolean":
+      case "array":
+      case "mixed":
+        break;
+      case "required":
+        validator2 = validator2.required();
+        break;
+      case "nullable":
+        validator2 = validator2.nullable();
+        break;
+      case "email":
+        validator2 = validator2.email();
+        break;
+      case "url":
+        validator2 = validator2.url();
+        break;
+      case "min":
+        validator2 = validator2.min(Number(rule.params));
+        break;
+      case "max":
+        validator2 = validator2.max(Number(rule.params));
+        break;
+      case "between": {
+        const [min2, max2] = rule.params.split(",").map(Number);
+        validator2 = validator2.min(min2).max(max2);
+        break;
+      }
+      case "in": {
+        const allowed = rule.params.split(",").map((v) => v.trim());
+        validator2 = validator2.oneOf(allowed);
+        break;
+      }
+      case "not_in": {
+        const disallowed = rule.params.split(",").map((v) => v.trim());
+        validator2 = validator2.notOneOf(disallowed);
+        break;
+      }
+      case "regex": {
+        const match2 = rule.params.match(/^\/(.+)\/([gimsuy]*)$/);
+        if (match2) {
+          validator2 = validator2.matches(new RegExp(match2[1], match2[2]));
+        }
+        break;
+      }
+      default:
+        console.warn(`[buildYupSchema] Unknown validation rule: "${rule.name}"`);
+    }
+  }
+  return validator2;
+};
+const setNestedShape = (rootShape, path, validator2) => {
+  const segments = path.split(".");
+  let current = rootShape;
+  for (let i2 = 0; i2 < segments.length - 1; i2++) {
+    const seg = segments[i2];
+    const nextSeg = segments[i2 + 1];
+    if (nextSeg === "*") {
+      const remainingPath = segments.slice(i2 + 2).join(".");
+      if (!current[seg]) {
+        current[seg] = { __type: "array", __shape: {} };
+      }
+      if (remainingPath) {
+        setNestedShape(current[seg].__shape, remainingPath, validator2);
+      } else {
+        current[seg].__itemValidator = validator2;
+      }
+      return;
     }
-    if (rules.min !== void 0) {
-      validator2 = validator2.min(rules.min);
+    if (seg === "*") {
+      continue;
+    }
+    if (!current[seg]) {
+      current[seg] = { __type: "object", __shape: {} };
     }
-    if (rules.max !== void 0) {
-      validator2 = validator2.max(rules.max);
+    current = current[seg].__shape;
+  }
+  const lastSeg = segments[segments.length - 1];
+  if (lastSeg !== "*") {
+    current[lastSeg] = validator2;
+  }
+};
+const buildShapeToYup = (shape) => {
+  const yupShape = {};
+  for (const [key, value] of Object.entries(shape)) {
+    if (value && value.__type === "array") {
+      const innerShape = buildShapeToYup(value.__shape);
+      yupShape[key] = value.__itemValidator ? create$2().of(value.__itemValidator) : create$2().of(create$3().shape(innerShape));
+    } else if (value && value.__type === "object") {
+      const innerShape = buildShapeToYup(value.__shape);
+      yupShape[key] = create$3().shape(innerShape);
+    } else {
+      yupShape[key] = value;
     }
-    if (rules.email) {
-      validator2 = validator2.email();
+  }
+  return yupShape;
+};
+const buildYupSchema = (validationConfig) => {
+  if (!validationConfig) return create$3();
+  const intermediateShape = {};
+  for (const [field, ruleString] of Object.entries(validationConfig)) {
+    const rules = parseRuleString(ruleString);
+    const validator2 = buildFieldValidator(rules);
+    if (field.includes(".")) {
+      setNestedShape(intermediateShape, field, validator2);
+    } else {
+      intermediateShape[field] = validator2;
     }
-    shape[field] = validator2;
   }
-  return create$3().shape(shape);
+  const yupShape = buildShapeToYup(intermediateShape);
+  return create$3().shape(yupShape);
 };
 const evaluateVisibilityRules = (visibilityRules, item, formContext) => {
   if (!Array.isArray(visibilityRules) || !formContext) return;
@@ -85646,7 +85548,8 @@ const _sfc_main = {
     const modelValue = useModel(__props, "modelValue");
     const props2 = __props;
     const emits = __emit;
-    const yupSchema = buildYupSchema(props2.schema.validation);
+    const yupSchema = computed(() => buildYupSchema(props2.schema.validation));
+    console.log("yup schema!");
     const form = useForm({ schema: yupSchema }, emits);
     const { formName, item } = form;
     provide("formContext", form);