@regle/schemas 0.7.6 → 0.8.0

package/dist/regle-schemas.cjs

@@ -2,7 +2,6 @@
 
 var core = require('@regle/core');
 var vue = require('vue');
-var rules = require('@regle/rules');
 
 // src/core/useRegleSchema.ts
 
@@ -45,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)) {
@@ -87,624 +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.issues) {
-      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 schema["~standard"].validate(value);
-        if (!result.issues) {
-          resolve({
-            $valid: true,
-            $issues: []
-          });
-        } else {
-          resolve({
-            $valid: false,
-            $issues: result.issues
-          });
-        }
-      });
+    if (!obj[lastProp]) {
+      obj[lastProp] = { ...obj[lastProp], $self: value };
     } else {
-      const result = schema["~standard"].validate(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;
-}
-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 { entries: allEntries, type: "object", kind: "schema", async: false };
-  } 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);
-    if (issueMessages?.length) {
-      return issueMessages.length ? issueMessages : "Error";
+      obj[lastProp].$self = (obj[lastProp].$self ??= []).concat(value);
     }
-    return [];
-  };
-}
-
-// 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((value) => {
-        const result = validation["~run"]({ value, typed: true }, {});
-        return {
-          $valid: !result.issues,
-          $issues: result.issues
-        };
-      }, extractIssuesMessages());
-    });
-  }
-  return {
-    $each: processValibotTypeDef(schema.item, state),
-    ...filteredSelfSchema
-  };
-}
-function transformZodValidatorAdapter(schema, additionalIssues) {
-  const isAsync = hasAsyncRefinement(schema);
-  function validatorFn(value) {
-    if (additionalIssues?.value?.length) {
-      return {
-        $valid: false,
-        // additionalIssues should already contain field error if there is a refinement in a parent
-        $issues: additionalIssues.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,
-        // additionalIssues should already contain field error if there is a refinement in a parent
-        $issues: result.error?.issues ?? []
-      };
-    }
-  }
-  if (schema && "__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) {
-  if (schema) {
-    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;
     }
-  } else {
-    return { success: true, data: {} };
-  }
-}
-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;
   }
+  return true;
 }
-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));
-    }
+function getDotPath(obj, propsArg, defaultValue) {
+  if (!obj) {
+    return defaultValue;
   }
-  return false;
-}
-function zodDiscriminatedUnionToRegle(schema, state, additionalIssues) {
-  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({
-                      schema: shape,
-                      state: vue.toRef(isObject(state.value) ? state.value : {}),
-                      additionalIssues
-                    })
-                  ];
-                }
-                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 = ["ZodDefault", "ZodCatch", "ZodNullable", "ZodOptional", "ZodReadonly"];
-function isDefWithInnerType(schema) {
-  if (schema._def && typeof schema._def === "object" && "typeName" in schema._def) {
-    return typesWithInnerTypes.includes(schema._def.typeName);
+  var props, prop;
+  if (Array.isArray(propsArg)) {
+    props = propsArg.slice(0);
   }
-  return false;
-}
-function isDefWithInnerSchema(schema) {
-  if (schema._def && typeof schema._def === "object" && "typeName" in schema._def) {
-    return "schema" in schema._def;
+  if (typeof propsArg == "string") {
+    props = propsArg.split(".");
   }
-  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;
-    }
+  if (typeof propsArg == "symbol") {
+    props = [propsArg];
   }
-  return undefined;
-}
-function processZodTypeDef({
-  schema,
-  state,
-  additionalIssues
-}) {
-  const schemaDef = getNestedInnerType2(schema);
-  if (schemaDef?._def && "typeName" in schemaDef._def) {
-    if (schemaDef._def.typeName === "ZodArray" || schemaDef._def.typeName === "ZodTuple") {
-      const schemaRef = zodArrayToRegle(schema, state, additionalIssues);
-      return schemaRef.zodRule;
-    } else if (schemaDef._def.typeName === "ZodObject" || schemaDef._def.typeName === "ZodIntersection") {
-      const schemaRef = zodObjectToRegle(
-        schemaDef,
-        state,
-        additionalIssues
-      );
-      return schemaRef.zodRule;
-    } else if (schemaDef._def.typeName === "ZodDiscriminatedUnion") {
-      const schemaRef = zodDiscriminatedUnionToRegle(
-        schemaDef,
-        state,
-        additionalIssues
-      );
-      return schemaRef.zodRule;
-    } else {
-      if (additionalIssues) {
-        return {
-          [schemaDef.constructor.name]: rules.withMessage(
-            rules.withParams(transformZodValidatorAdapter(schema, additionalIssues), [state]),
-            extractIssuesMessages()
-          )
-        };
-      }
-      return {
-        [schemaDef.constructor.name]: rules.withMessage(
-          transformZodValidatorAdapter(schema),
-          extractIssuesMessages()
-        )
-      };
-    }
+  if (!Array.isArray(props)) {
+    throw new Error("props arg must be an array, a string or a symbol");
   }
-  return {};
-}
-
-// src/core/converters/zod/validators/zodArrayToRegle.ts
-function getNestedZodArraySchema(schema, effects = []) {
-  if (schema._def && "typeName" in schema._def) {
-    if (schema._def.typeName === "ZodEffects") {
-      return getNestedZodArraySchema(
-        schema._def.schema,
-        effects.concat([schema._def.effect])
-      );
-    } else {
-      return { nestedSchema: schema, nestedEffects: effects };
+  while (props.length) {
+    prop = props.shift();
+    if (!obj) {
+      return defaultValue;
     }
-  }
-  return { nestedSchema: undefined };
-}
-function zodArrayToRegle(schema, state, rootAdditionalIssues) {
-  const { nestedSchema, nestedEffects } = getNestedZodArraySchema(schema);
-  const zodRule = vue.ref({});
-  if (nestedSchema) {
-    const arrayValidators = nestedSchema._def.typeName === "ZodArray" ? {
-      ...!!nestedSchema._def.minLength && { minLength: rules.minLength(nestedSchema._def.minLength?.value) },
-      ...!!nestedSchema._def.maxLength && { maxLength: rules.maxLength(nestedSchema._def.maxLength?.value) },
-      ...!!nestedSchema._def.exactLength && { exactLength: rules.exactLength(nestedSchema._def.exactLength?.value) }
-    } : {};
-    if (nestedEffects?.length) {
-      const scope = vue.effectScope();
-      scope.run(() => {
-        const localAdditionalIssues = vue.ref([]);
-        const additionalIssues = vue.computed(() => {
-          return localAdditionalIssues.value.concat(rootAdditionalIssues?.value ?? []);
-        });
-        if (!rootAdditionalIssues) {
-          vue.watch(
-            state,
-            () => {
-              if (nestedSchema) {
-                localAdditionalIssues.value = schema.safeParse(state.value).error?.issues.filter((f) => f.code === "custom") ?? [];
-              }
-            },
-            { deep: true, immediate: true }
-          );
-        }
-        if (nestedSchema) {
-          const items = nestedSchema._def.typeName === "ZodArray" ? nestedSchema._def.type : nestedSchema._def.items;
-          const selfAdditionalIssues = vue.computed(() => additionalIssues.value.filter((f) => !f.path.length));
-          zodRule.value = {
-            $each: (_, index) => {
-              const fieldIssues = vue.computed(() => {
-                return additionalIssues.value?.filter((f) => f.code === "custom")?.filter((f) => f.path[0] === index.toString()).map((m) => {
-                  const [first, ...rest] = m.path;
-                  return {
-                    ...m,
-                    path: rest
-                  };
-                });
-              });
-              return processZodTypeDef({ schema: items, state, additionalIssues: fieldIssues });
-            },
-            selfValidator: rules.withMessage(
-              rules.withParams(transformZodValidatorAdapter(undefined, selfAdditionalIssues), [
-                state,
-                selfAdditionalIssues
-              ]),
-              extractIssuesMessages()
-            )
-          };
-        } else {
-          zodRule.value = {};
-        }
-        vue.onScopeDispose(() => {
-          scope.stop();
-        });
-      });
-    } else {
-      const items = nestedSchema._def.typeName === "ZodArray" ? nestedSchema._def.type : nestedSchema._def.items;
-      zodRule.value = {
-        $each: processZodTypeDef({ schema: items, state, additionalIssues: rootAdditionalIssues }),
-        ...arrayValidators
-      };
+    if (!prop) {
+      return defaultValue;
     }
-  }
-  return vue.reactive({ zodRule });
-}
-function getNestedZodObjectSchema(schema, effects = []) {
-  if (schema._def && "typeName" in schema._def) {
-    if (schema._def.typeName === "ZodEffects") {
-      return getNestedZodObjectSchema(
-        schema._def.schema,
-        effects.concat([schema._def.effect])
-      );
-    } else if (schema._def.typeName === "ZodIntersection") {
-      const { nestedSchema: leftObject, nestedEffects: leftEffects = [] } = getNestedZodObjectSchema(
-        schema._def.left
-      );
-      const { nestedSchema: rightObject, nestedEffects: rightEffects = [] } = getNestedZodObjectSchema(
-        schema._def.right
-      );
-      if (leftObject && rightObject) {
-        return getNestedZodObjectSchema(
-          leftObject.merge(rightObject),
-          effects.concat(leftEffects).concat(rightEffects)
-        );
-      }
-      return { nestedSchema: undefined };
-    } else {
-      return { nestedSchema: schema, nestedEffects: effects };
+    obj = obj[prop];
+    if (obj === undefined) {
+      return defaultValue;
     }
   }
-  return { nestedSchema: undefined };
+  return obj;
 }
-function zodObjectToRegle(schema, state, rootAdditionalIssues) {
-  const { nestedSchema, nestedEffects } = getNestedZodObjectSchema(schema);
-  const zodRule = vue.ref({});
-  if (nestedSchema) {
-    if (nestedEffects?.length) {
-      const scope = vue.effectScope();
-      scope.run(() => {
-        const localAdditionalIssues = vue.ref([]);
-        const additionalIssues = vue.computed(() => {
-          return localAdditionalIssues.value.concat(rootAdditionalIssues?.value ?? []);
-        });
-        vue.watch(
-          state,
-          () => {
-            if (nestedSchema?._def?.typeName === "ZodObject") {
-              localAdditionalIssues.value = (rootAdditionalIssues?.value ?? []).concat(
-                schema.safeParse(state.value).error?.issues.filter((f) => f.code === "custom") ?? []
-              );
-            }
-          },
-          { deep: true, flush: "sync", immediate: true }
-        );
-        if (nestedSchema?._def?.typeName === "ZodObject") {
-          zodRule.value = 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);
-                const fieldIssues = vue.computed(() => {
-                  return additionalIssues.value?.filter((f) => f.path[0] === key).map((m) => {
-                    const [_, ...rest] = m.path;
-                    return {
-                      ...m,
-                      path: rest
-                    };
-                  });
-                });
-                return [
-                  key,
-                  processZodTypeDef({
-                    schema: shape,
-                    state: childState,
-                    additionalIssues: fieldIssues
-                  }),
-                  [state]
-                ];
-              }
-              return [key, {}];
-            })
-          );
-        } else {
-          zodRule.value = {};
-        }
-        vue.onScopeDispose(() => {
-          scope.stop();
-        });
-      });
-    } else {
-      zodRule.value = 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({
-                schema: shape,
-                state: childState,
-                additionalIssues: rootAdditionalIssues
-              })
-            ];
-          }
-          return [key, {}];
-        })
-      );
-    }
+function prototypeCheck(prop) {
+  if (prop == "__proto__" || prop == "constructor" || prop == "prototype") {
+    throw new Error("setting of prototype values not supported");
   }
-  return vue.reactive({ zodRule });
 }
 
 // src/core/useRegleSchema.ts
@@ -718,82 +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") {
-              const objectResult = zodObjectToRegle(computedSchema.value, processedState);
-              convertedRules.value = objectResult.zodRule;
-            } else if (computedSchema.value["~standard"].vendor === "valibot") {
-              convertedRules.value = vue.reactive(valibotObjectToRegle(computedSchema.value, processedState));
-            } else if (computedSchema.value?.["~standard"]?.vendor) {
-              console.warn(
-                `This RPC library "${computedSchema.value["~standard"].vendor}" is not supported yet in 'rules' mode, switch to the "schema" mode option`
-              );
-            } else {
-              console.warn(`Only "standard-schema" compatible libraries are supported`);
-            }
-          }
-        },
-        { 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;
-      };
-      if (!computedSchema.value?.["~standard"]) {
-        throw new Error(`Only "standard-schema" compatible libraries are supported`);
-      }
-      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,
@@ -801,7 +200,7 @@ function createUseRegleSchemaComposable(options, shortcuts) {
       schemaErrors: customErrors,
       initialState,
       shortcuts,
-      schemaMode: mode === "schema",
+      schemaMode: true,
       onValidate
     });
     return {
@@ -812,16 +211,6 @@ function createUseRegleSchemaComposable(options, shortcuts) {
 }
 var useRegleSchema = createUseRegleSchemaComposable();
 function withDeps(schema, depsArray) {
-  if (!Object.hasOwn(schema, "__depsArray")) {
-    Object.defineProperties(schema, {
-      __depsArray: {
-        value: depsArray,
-        enumerable: false,
-        configurable: false,
-        writable: false
-      }
-    });
-  }
   return schema;
 }
 function createInferValibotSchemaHelper() {