@regle/schemas 0.7.5 → 0.8.0

package/dist/regle-schemas.cjs

@@ -2,32 +2,6 @@
 
 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
 
@@ -70,12 +44,6 @@ function cloneDeep(obj) {
 }
 
 // ../shared/utils/object.utils.ts
-function isObject(obj) {
-  if (obj && (obj instanceof Date || obj.constructor.name == "File" || obj.constructor.name == "FileList")) {
-    return false;
-  }
-  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
-}
 function setObjectError(obj, propsArg, value, isArray) {
   var props, lastProp;
   if (Array.isArray(propsArg)) {
@@ -112,447 +80,56 @@ function setObjectError(obj, propsArg, value, isArray) {
     }
   }
   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: []
-      };
+    if (!obj[lastProp]) {
+      obj[lastProp] = { ...obj[lastProp], $self: value };
     } else {
-      return {
-        $valid: false,
-        $issues: result.issues
-      };
+      obj[lastProp].$self = (obj[lastProp].$self ??= []).concat(value);
     }
-  };
-  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: []
-      };
+    if (Array.isArray(obj[lastProp])) {
+      obj[lastProp] = obj[lastProp].concat(value);
     } 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 {};
+      obj[lastProp] = value;
     }
   }
+  return true;
 }
-function isAsyncFunctionOrPromiseReturning(fn) {
-  if (typeof fn !== "function") return false;
-  if (fn.constructor.name === "AsyncFunction") {
-    return true;
+function getDotPath(obj, propsArg, defaultValue) {
+  if (!obj) {
+    return defaultValue;
   }
-  try {
-    const result = fn();
-    return result instanceof Promise;
-  } catch {
-    return false;
+  var props, prop;
+  if (Array.isArray(propsArg)) {
+    props = propsArg.slice(0);
   }
-}
-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));
-    }
+  if (typeof propsArg == "string") {
+    props = propsArg.split(".");
   }
-  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);
+  if (typeof propsArg == "symbol") {
+    props = [propsArg];
   }
-  return false;
-}
-function isDefWithInnerSchema(schema) {
-  if (schema._def && typeof schema._def === "object" && "typeName" in schema._def) {
-    return "schema" in schema._def;
+  if (!Array.isArray(props)) {
+    throw new Error("props arg must be an array, a string or a symbol");
   }
-  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;
+  while (props.length) {
+    prop = props.shift();
+    if (!obj) {
+      return defaultValue;
     }
-  }
-  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()
-        )
-      };
+    if (!prop) {
+      return defaultValue;
     }
-  }
-  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;
+    obj = obj[prop];
+    if (obj === undefined) {
+      return defaultValue;
     }
   }
-  return undefined;
+  return obj;
 }
-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 {};
+function prototypeCheck(prop) {
+  if (prop == "__proto__" || prop == "constructor" || prop == "prototype") {
+    throw new Error("setting of prototype values not supported");
   }
-  return {};
 }
 
 // src/core/useRegleSchema.ts
@@ -566,72 +143,56 @@ function createUseRegleSchemaComposable(options, shortcuts) {
   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
+      ...options2
     };
     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);
+    if (!computedSchema.value?.["~standard"]) {
+      throw new Error(`Only "standard-schema" compatible libraries are supported`);
+    }
+    function issuesToRegleErrors(result) {
+      const output = {};
+      if (result.issues) {
+        const errors = result.issues.map((issue) => {
+          const path = issue.path?.map((item) => typeof item === "object" ? item.key : item.toString()).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) || Array.isArray(getDotPath(processedState.value, path));
           return {
-            result: !result.issues?.length,
-            data: processedState.value
+            path,
+            message: issue.message,
+            isArray
           };
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
+        });
+        errors.forEach((error) => {
+          setObjectError(output, error.path, [error.message], error.isArray);
+        });
+      }
+      return output;
     }
+    async function computeErrors() {
+      let result = computedSchema.value["~standard"].validate(processedState.value);
+      if (result instanceof Promise) {
+        result = await result;
+      }
+      customErrors.value = issuesToRegleErrors(result);
+      return result;
+    }
+    vue.watch([processedState, computedSchema], computeErrors, { deep: true, immediate: true });
+    onValidate = async () => {
+      try {
+        const result = await computeErrors();
+        return {
+          result: !result.issues?.length,
+          data: processedState.value
+        };
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
     const regle = core.useRootStorage({
       scopeRules: convertedRules,
       state: processedState,
@@ -639,7 +200,7 @@ function createUseRegleSchemaComposable(options, shortcuts) {
       schemaErrors: customErrors,
       initialState,
       shortcuts,
-      schemaMode: mode === "schema",
+      schemaMode: true,
       onValidate
     });
     return {
@@ -650,7 +211,7 @@ function createUseRegleSchemaComposable(options, shortcuts) {
 }
 var useRegleSchema = createUseRegleSchemaComposable();
 function withDeps(schema, depsArray) {
-  return { ...schema, __depsArray: depsArray };
+  return schema;
 }
 function createInferValibotSchemaHelper() {
   function inferRules(state, rulesFactory) {