@regle/schemas 0.7.0

package/dist/regle-schemas.cjs

@@ -0,0 +1,676 @@
+'use strict';
+
+var core = require('@regle/core');
+var vue = require('vue');
+var rules = require('@regle/rules');
+var v3 = require('valibot');
+var z = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var v3__namespace = /*#__PURE__*/_interopNamespace(v3);
+var z__default = /*#__PURE__*/_interopDefault(z);
+
+// src/core/useRegleSchema.ts
+
+// ../shared/utils/cloneDeep.ts
+function getRegExpFlags(regExp) {
+  if (typeof regExp.source.flags == "string") {
+    return regExp.source.flags;
+  } else {
+    let flags = [];
+    regExp.global && flags.push("g");
+    regExp.ignoreCase && flags.push("i");
+    regExp.multiline && flags.push("m");
+    regExp.sticky && flags.push("y");
+    regExp.unicode && flags.push("u");
+    return flags.join("");
+  }
+}
+function cloneDeep(obj) {
+  let result = obj;
+  let type = {}.toString.call(obj).slice(8, -1);
+  if (type == "Set") {
+    result = new Set([...obj].map((value) => cloneDeep(value)));
+  }
+  if (type == "Map") {
+    result = new Map([...obj].map((kv) => [cloneDeep(kv[0]), cloneDeep(kv[1])]));
+  }
+  if (type == "Date") {
+    result = new Date(obj.getTime());
+  }
+  if (type == "RegExp") {
+    result = RegExp(obj.source, getRegExpFlags(obj));
+  }
+  if (type == "Array" || type == "Object") {
+    result = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+      result[key] = cloneDeep(obj[key]);
+    }
+  }
+  return result;
+}
+
+// ../shared/utils/object.utils.ts
+function isObject(obj) {
+  if (obj instanceof Date || obj instanceof File) {
+    return false;
+  }
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+function setObjectError(obj, propsArg, value, isArray) {
+  var props, lastProp;
+  if (Array.isArray(propsArg)) {
+    props = propsArg.slice(0);
+  }
+  if (typeof propsArg == "string") {
+    props = propsArg.split(".");
+  }
+  if (typeof propsArg == "symbol") {
+    props = [propsArg];
+  }
+  if (!Array.isArray(props)) {
+    throw new Error("props arg must be an array, a string or a symbol");
+  }
+  lastProp = props.pop();
+  if (!lastProp) {
+    return false;
+  }
+  prototypeCheck(lastProp);
+  var thisProp;
+  while (thisProp = props.shift()) {
+    prototypeCheck(thisProp);
+    if (!isNaN(parseInt(thisProp))) {
+      (obj.$each ??= [])[thisProp] = {};
+      obj = obj.$each[thisProp];
+    } else {
+      if (typeof obj[thisProp] == "undefined") {
+        obj[thisProp] = {};
+      }
+      obj = obj[thisProp];
+    }
+    if (!obj || typeof obj != "object") {
+      return false;
+    }
+  }
+  if (isArray) {
+    obj[lastProp] = { ...obj[lastProp], $self: value };
+  } else {
+    obj[lastProp] = value;
+  }
+  return true;
+}
+function prototypeCheck(prop) {
+  if (prop == "__proto__" || prop == "constructor" || prop == "prototype") {
+    throw new Error("setting of prototype values not supported");
+  }
+}
+function transformValibotAdapter(schema) {
+  const isAsync = schema.async;
+  const validatorFn = (value) => {
+    const result = trySafeTransform(schema, value);
+    if (result instanceof Promise) {
+      return result;
+    }
+    if (result.success) {
+      return {
+        $valid: true,
+        $issues: []
+      };
+    } else {
+      return {
+        $valid: false,
+        $issues: result.issues
+      };
+    }
+  };
+  if ("__depsArray" in schema && Array.isArray(schema.__depsArray) && schema.__depsArray.length) {
+    return isAsync ? rules.withAsync(validatorFn, schema.__depsArray) : rules.withParams(validatorFn, schema.__depsArray);
+  }
+  return isAsync ? rules.withAsync(validatorFn) : validatorFn;
+}
+function trySafeTransform(schema, value) {
+  try {
+    if (schema.async) {
+      return new Promise(async (resolve) => {
+        const result = await v3__namespace.safeParseAsync(schema, value);
+        if (result.success) {
+          resolve({
+            $valid: true,
+            $issues: []
+          });
+        } else {
+          resolve({
+            $valid: false,
+            $issues: result.issues
+          });
+        }
+      });
+    } else {
+      const result = v3__namespace.safeParse(schema, value);
+      return result;
+    }
+  } catch (e) {
+    return {};
+  }
+}
+
+// src/core/converters/valibot/guards.ts
+function isIntersectSchema(schema) {
+  return schema.type === "intersect";
+}
+function isObjectSchema(schema) {
+  return schema.type === "object";
+}
+function isWrappedType(schema) {
+  return "wrapped" in schema;
+}
+
+// src/core/converters/valibot/validators/valibotObjectToRegle.ts
+function getNestedValibotObjectSchema(schema) {
+  if (isIntersectSchema(schema)) {
+    const allEntries = schema.options.reduce(
+      (acc, value) => {
+        const nestedSchema = getNestedValibotObjectSchema(value);
+        if (nestedSchema) {
+          acc = {
+            ...acc,
+            ...nestedSchema.entries
+          };
+        }
+        return acc;
+      },
+      {}
+    );
+    return v3__namespace.object({ ...allEntries });
+  } else if (isObjectSchema(schema)) {
+    return schema;
+  } else if (isWrappedType(schema)) {
+    return getNestedValibotObjectSchema(schema.wrapped);
+  } else {
+    return undefined;
+  }
+}
+function valibotObjectToRegle(schema, state) {
+  const nestedSchema = getNestedValibotObjectSchema(schema);
+  if (nestedSchema) {
+    return Object.fromEntries(
+      Object.entries(nestedSchema.entries).map(([key, shape]) => {
+        if (typeof shape === "object") {
+          const childState = vue.toRef(isObject(state.value) ? state.value : {}, key);
+          return [key, processValibotTypeDef(shape, childState)];
+        }
+        return [key, {}];
+      })
+    );
+  }
+  return {};
+}
+
+// src/core/converters/valibot/validators/valibotVariantToRegle.ts
+function isLiteralSchema(schema) {
+  return schema?.type === "literal";
+}
+function valibotVariantToRegle(schema, state) {
+  const scope = vue.effectScope();
+  const scopeState = scope.run(() => {
+    const valibotRule = vue.ref({});
+    vue.watch(
+      state,
+      () => {
+        if (isObject(state.value) && state.value[schema.key]) {
+          const selectedDiscriminant = schema.options.find((o) => {
+            const nestedSchema = getNestedValibotObjectSchema(o);
+            const schemaVariantKey = nestedSchema?.entries[schema.key];
+            if (isLiteralSchema(schemaVariantKey) && isObject(state.value)) {
+              return schemaVariantKey.literal === state.value[schema.key];
+            }
+            return false;
+          });
+          if (selectedDiscriminant && isObjectSchema(selectedDiscriminant)) {
+            valibotRule.value = Object.fromEntries(
+              Object.entries(selectedDiscriminant.entries).map(([key, shape]) => {
+                return [key, processValibotTypeDef(shape, vue.toRef(isObject(state.value) ? state.value : {}, key))];
+              })
+            );
+          } else {
+            valibotRule.value = {};
+          }
+        } else {
+          valibotRule.value = {
+            [schema.key]: { required: rules.required }
+          };
+        }
+      },
+      { deep: true, flush: "pre", immediate: true }
+    );
+    vue.onScopeDispose(() => {
+      scope.stop();
+    });
+    return { valibotRule };
+  });
+  return scopeState;
+}
+
+// src/core/converters/extractIssuesMessages.ts
+function extractIssuesMessages() {
+  return (metadata) => {
+    const issueMessages = metadata.$issues?.map((issue) => issue.message);
+    return issueMessages.length ? issueMessages : "Error";
+  };
+}
+
+// src/core/converters/valibot/processValibotTypeDef.ts
+function isArraySchema(schema) {
+  return schema.type === "array";
+}
+function isObjectSchema2(schema) {
+  return schema.type === "object";
+}
+function isVariantSchema(schema) {
+  return schema.type === "variant";
+}
+function getNestedInnerType(schema) {
+  if (isWrappedType(schema)) {
+    return getNestedInnerType(schema.wrapped);
+  } else {
+    return schema;
+  }
+}
+function processValibotTypeDef(schema, state) {
+  const nestedSchema = getNestedInnerType(schema);
+  if (isArraySchema(nestedSchema)) {
+    return valibotArrayToRegle(nestedSchema, state);
+  } else if (isObjectSchema2(nestedSchema)) {
+    return valibotObjectToRegle(nestedSchema, state);
+  } else if (isVariantSchema(nestedSchema)) {
+    const valibotRule = valibotVariantToRegle(nestedSchema, state);
+    return valibotRule.valibotRule;
+  } else {
+    return {
+      [nestedSchema.type]: rules.withMessage(transformValibotAdapter(nestedSchema), extractIssuesMessages())
+    };
+  }
+}
+
+// src/core/converters/valibot/validators/valibotArrayToRegle.ts
+function valibotArrayToRegle(schema, state) {
+  let filteredSelfSchema = {};
+  if ("pipe" in schema) {
+    schema.pipe.filter((f) => f.kind === "validation").forEach((validation) => {
+      filteredSelfSchema[validation.type] = rules.withMessage(
+        transformValibotAdapter(v3__namespace.pipe(v3__namespace.array(v3__namespace.any()), validation)),
+        extractIssuesMessages()
+      );
+    });
+  }
+  return {
+    $each: processValibotTypeDef(schema.item, state),
+    ...filteredSelfSchema
+  };
+}
+function transformZodValidatorAdapter(schema) {
+  const isAsync = hasAsyncRefinement(schema);
+  const validatorFn = (value) => {
+    const result = trySafeTransform2(schema, value);
+    if (result instanceof Promise) {
+      return result;
+    }
+    if (result.success) {
+      return {
+        $valid: true,
+        $issues: []
+      };
+    } else {
+      return {
+        $valid: false,
+        $issues: result.error.issues
+      };
+    }
+  };
+  if ("__depsArray" in schema && Array.isArray(schema.__depsArray) && schema.__depsArray.length) {
+    return isAsync ? rules.withAsync(validatorFn, schema.__depsArray) : rules.withParams(validatorFn, schema.__depsArray);
+  }
+  return isAsync ? rules.withAsync(validatorFn) : validatorFn;
+}
+function trySafeTransform2(schema, value) {
+  try {
+    const result = schema.safeParse(value);
+    return result;
+  } catch (e) {
+    try {
+      return new Promise(async (resolve) => {
+        const result = await schema.safeParseAsync(value);
+        if (result.success) {
+          resolve({
+            $valid: true,
+            $issues: []
+          });
+        } else {
+          resolve({
+            $valid: false,
+            $issues: result.error.issues
+          });
+        }
+      });
+    } catch (e2) {
+      return {};
+    }
+  }
+}
+function isAsyncFunctionOrPromiseReturning(fn) {
+  if (typeof fn !== "function") return false;
+  if (fn.constructor.name === "AsyncFunction") {
+    return true;
+  }
+  try {
+    const result = fn();
+    return result instanceof Promise;
+  } catch {
+    return false;
+  }
+}
+function hasAsyncRefinement(schema) {
+  if (schema?._def) {
+    if (schema._def.typeName === "ZodEffects") {
+      const effect = schema._def.effect;
+      return isAsyncFunctionOrPromiseReturning(effect.refinement || effect.transform);
+    }
+    if (schema._def.typeName === "ZodObject") {
+      return Object.values(schema._def.shape()).some((schema2) => hasAsyncRefinement(schema2));
+    }
+    if (schema._def.typeName === "ZodUnion" || schema._def.typeName === "ZodIntersection") {
+      return schema._def.options.some(hasAsyncRefinement);
+    }
+    if (schema._def.typeName === "ZodArray") {
+      return hasAsyncRefinement(schema._def.type);
+    }
+    if (schema._def.typeName === "ZodOptional" || schema._def.typeName === "ZodNullable") {
+      return hasAsyncRefinement(schema._def.innerType);
+    }
+    if (schema._def.typeName === "ZodTuple") {
+      return schema._def.items.some(hasAsyncRefinement);
+    }
+    if (schema._def.typeName === "ZodString" || schema._def.typeName === "ZodNumber" || schema._def.typeName === "ZodDate") {
+      return schema._def.checks?.some((check) => isAsyncFunctionOrPromiseReturning(check.refinement));
+    }
+  }
+  return false;
+}
+function zodDiscriminatedUnionToRegle(schema, state) {
+  const scope = vue.effectScope();
+  const scopeState = scope.run(() => {
+    const zodRule = vue.ref({});
+    vue.watch(
+      state,
+      () => {
+        if (isObject(state.value) && state.value[schema._def.discriminator]) {
+          const selectedDiscriminant = schema._def.optionsMap.get(state.value[schema._def.discriminator]);
+          if (selectedDiscriminant) {
+            zodRule.value = Object.fromEntries(
+              Object.entries(selectedDiscriminant._def.shape()).map(([key, shape]) => {
+                if (typeof shape === "object" && "_def" in shape) {
+                  return [key, processZodTypeDef(shape, vue.toRef(isObject(state.value) ? state.value : {}, key))];
+                }
+                return [key, {}];
+              })
+            );
+          } else {
+            zodRule.value = {};
+          }
+        } else {
+          zodRule.value = {
+            [schema._def.discriminator]: { required: rules.required }
+          };
+        }
+      },
+      { deep: true, flush: "pre", immediate: true }
+    );
+    vue.onScopeDispose(() => {
+      scope.stop();
+    });
+    return { zodRule };
+  });
+  return scopeState;
+}
+
+// src/core/converters/zod/processZodTypeDef.ts
+var typesWithInnerTypes = [
+  z__default.default.ZodFirstPartyTypeKind.ZodDefault,
+  z__default.default.ZodFirstPartyTypeKind.ZodCatch,
+  z__default.default.ZodFirstPartyTypeKind.ZodNullable,
+  z__default.default.ZodFirstPartyTypeKind.ZodOptional,
+  z__default.default.ZodFirstPartyTypeKind.ZodReadonly
+];
+function isDefWithInnerType(schema) {
+  if (schema._def && typeof schema._def === "object" && "typeName" in schema._def) {
+    return typesWithInnerTypes.includes(schema._def.typeName);
+  }
+  return false;
+}
+function isDefWithInnerSchema(schema) {
+  if (schema._def && typeof schema._def === "object" && "typeName" in schema._def) {
+    return "schema" in schema._def;
+  }
+  return false;
+}
+function getNestedInnerType2(schema) {
+  if (schema?._def && typeof schema._def === "object" && "typeName" in schema._def) {
+    if (isDefWithInnerType(schema)) {
+      return getNestedInnerType2(schema._def.innerType);
+    } else if (isDefWithInnerSchema(schema)) {
+      return getNestedInnerType2(schema._def.schema);
+    } else {
+      return schema;
+    }
+  }
+  return undefined;
+}
+function processZodTypeDef(schema, state) {
+  const schemaDef = getNestedInnerType2(schema);
+  if (schemaDef?._def && "typeName" in schemaDef._def) {
+    if (schemaDef._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodArray || schemaDef._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodTuple) {
+      return zodArrayToRegle(schema, state);
+    } else if (schemaDef._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodObject || schemaDef._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodIntersection) {
+      return zodObjectToRegle(schemaDef, state);
+    } else if (schemaDef._def.typeName === z__default.default.ZodFirstPartyTypeKind.ZodDiscriminatedUnion) {
+      const zodRule = zodDiscriminatedUnionToRegle(schemaDef, state);
+      return zodRule.zodRule;
+    } else {
+      return {
+        [schemaDef.constructor.name]: rules.withMessage(
+          transformZodValidatorAdapter(schema),
+          extractIssuesMessages()
+        )
+      };
+    }
+  }
+  return {};
+}
+
+// src/core/converters/zod/validators/zodArrayToRegle.ts
+function zodArrayToRegle(schema, state) {
+  const arrayValidators = schema._def.typeName === z.z.ZodFirstPartyTypeKind.ZodArray ? {
+    ...!!schema._def.minLength && { minLength: rules.minLength(schema._def.minLength?.value) },
+    ...!!schema._def.maxLength && { maxLength: rules.maxLength(schema._def.maxLength?.value) },
+    ...!!schema._def.exactLength && { exactLength: rules.exactLength(schema._def.exactLength?.value) }
+  } : {};
+  const items = schema._def.typeName === z.z.ZodFirstPartyTypeKind.ZodArray ? schema._def.type : schema._def.items;
+  return {
+    $each: processZodTypeDef(items, state),
+    ...arrayValidators
+  };
+}
+function getNestedZodObjectSchema(schema) {
+  if (schema._def && "typeName" in schema._def) {
+    if (schema._def.typeName === z.z.ZodFirstPartyTypeKind.ZodEffects) {
+      return getNestedZodObjectSchema(schema._def.schema);
+    } else if (schema._def.typeName === z.z.ZodFirstPartyTypeKind.ZodIntersection) {
+      const leftObject = getNestedZodObjectSchema(schema._def.left);
+      const rightObject = getNestedZodObjectSchema(schema._def.right);
+      if (leftObject && rightObject) {
+        return getNestedZodObjectSchema(leftObject.merge(rightObject));
+      }
+      return undefined;
+    } else {
+      return schema;
+    }
+  }
+  return undefined;
+}
+function zodObjectToRegle(schema, state) {
+  if (schema && "_def" in schema && "typeName" in schema._def) {
+    const nestedSchema = getNestedZodObjectSchema(schema);
+    if (nestedSchema?._def?.typeName === z.z.ZodFirstPartyTypeKind.ZodObject) {
+      return Object.fromEntries(
+        Object.entries(nestedSchema._def.shape()).map(([key, shape]) => {
+          if (shape && typeof shape === "object" && "_def" in shape) {
+            const childState = vue.toRef(isObject(state.value) ? state.value : {}, key);
+            return [key, processZodTypeDef(shape, childState)];
+          }
+          return [key, {}];
+        })
+      );
+    }
+    return {};
+  }
+  return {};
+}
+
+// src/core/useRegleSchema.ts
+function createUseRegleSchemaComposable(options, shortcuts) {
+  const globalOptions = {
+    autoDirty: options?.autoDirty,
+    lazy: options?.lazy,
+    rewardEarly: options?.rewardEarly,
+    clearExternalErrorsOnChange: options?.clearExternalErrorsOnChange
+  };
+  function useRegleSchema2(state, schema, options2) {
+    const convertedRules = vue.ref({});
+    const computedSchema = vue.computed(() => vue.unref(schema));
+    const { mode = "rules", ...regleOptions } = options2 ?? {};
+    const resolvedOptions = {
+      ...globalOptions,
+      ...regleOptions
+    };
+    const processedState = vue.isRef(state) ? state : vue.ref(state);
+    const initialState = vue.ref({ ...cloneDeep(processedState.value) });
+    const customErrors = vue.ref({});
+    let onValidate = undefined;
+    if (mode === "rules") {
+      vue.watch(
+        computedSchema,
+        () => {
+          if (computedSchema.value && typeof computedSchema.value === "object") {
+            if (computedSchema.value["~standard"].vendor === "zod") {
+              convertedRules.value = vue.reactive(zodObjectToRegle(computedSchema.value, processedState));
+            } else if (computedSchema.value["~standard"].vendor === "valibot") {
+              convertedRules.value = vue.reactive(valibotObjectToRegle(computedSchema.value, processedState));
+            }
+          }
+        },
+        { deep: true, immediate: true, flush: "post" }
+      );
+    } else {
+      let issuesToRegleErrors2 = function(result) {
+        const output = {};
+        if (result.issues) {
+          const errors = result.issues.map((issue) => {
+            const path = issue.path?.map((item) => typeof item === "object" ? item.key : item).join(".");
+            const lastItem = issue.path?.[issue.path.length - 1];
+            const isArray = (typeof lastItem === "object" && "value" in lastItem ? Array.isArray(lastItem.value) : false) || ("type" in issue ? issue.type === "array" : false);
+            return {
+              path,
+              message: issue.message,
+              isArray
+            };
+          });
+          errors.forEach((error) => {
+            setObjectError(output, error.path, [error.message], error.isArray);
+          });
+        }
+        return output;
+      };
+      const emptySkeleton = computedSchema.value["~standard"].validate(initialState.value);
+      customErrors.value = issuesToRegleErrors2(emptySkeleton);
+      vue.watch(
+        [processedState, computedSchema],
+        async () => {
+          const result = await computedSchema.value["~standard"].validate(processedState.value);
+          customErrors.value = issuesToRegleErrors2(result);
+        },
+        { deep: true, immediate: true, flush: "post" }
+      );
+      onValidate = async () => {
+        try {
+          const result = await computedSchema.value["~standard"].validate(processedState.value);
+          customErrors.value = issuesToRegleErrors2(result);
+          return {
+            result: !result.issues?.length,
+            data: processedState.value
+          };
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+    }
+    const regle = core.useRootStorage({
+      scopeRules: convertedRules,
+      state: processedState,
+      options: resolvedOptions,
+      schemaErrors: customErrors,
+      initialState,
+      shortcuts,
+      schemaMode: mode === "schema",
+      onValidate
+    });
+    return {
+      r$: regle.regle
+    };
+  }
+  return useRegleSchema2;
+}
+var useRegleSchema = createUseRegleSchemaComposable();
+function withDeps(schema, depsArray) {
+  return { ...schema, __depsArray: depsArray };
+}
+function createInferValibotSchemaHelper() {
+  function inferRules(state, rulesFactory) {
+    return rulesFactory;
+  }
+  return inferRules;
+}
+var inferSchema = createInferValibotSchemaHelper();
+
+// src/core/defineRegleSchemaConfig.ts
+function defineRegleSchemaConfig({
+  modifiers,
+  shortcuts
+}) {
+  const useRegleSchema2 = createUseRegleSchemaComposable(modifiers, shortcuts);
+  const inferSchema2 = createInferValibotSchemaHelper();
+  return { useRegleSchema: useRegleSchema2, inferSchema: inferSchema2 };
+}
+
+exports.defineRegleSchemaConfig = defineRegleSchemaConfig;
+exports.inferSchema = inferSchema;
+exports.useRegleSchema = useRegleSchema;
+exports.withDeps = withDeps;