@eslint-react/shared 1.5.12 → 1.5.13-next.1

package/dist/index.mjs

@@ -187,9 +187,6 @@ var getDocsUrl = (pluginName) => (ruleName) => {
   return `${WEBSITE_URL}/rules/${pluginName}-${ruleName}`;
 };
 var createRuleForPlugin = (pluginName) => ESLintUtils.RuleCreator(getDocsUrl(pluginName));
-function defaultArgs(arg1, arg2) {
-  return Array.isArray(arg1) ? [void 0, arg1] : [arg1, arg2];
-}
 var store2;
 function getGlobalMessage(lang) {
   return store2?.get(lang);
@@ -202,116 +199,77 @@ var store4;
 function getSpecificMessage(reference, lang) {
   return store4?.get(reference)?.get(lang);
 }
-function i18n(schema, context, reference, config, issue) {
-  const message = context.message ?? getSpecificMessage(reference, issue.lang) ?? (schema ? getSchemaMessage(issue.lang) : null) ?? config?.message ?? getGlobalMessage(issue.lang) ?? issue.message;
-  return typeof message === "function" ? message(issue) : message;
-}
-function schemaResult(typed, output, issues) {
-  return { typed, output, issues };
-}
-function stringify(input) {
+function _stringify(input) {
   let type = typeof input;
   if (type === "object") {
     type = input ? Object.getPrototypeOf(input).constructor.name : "null";
   }
   return type === "string" ? `"${input}"` : type === "number" || type === "bigint" || type === "boolean" ? `${input}` : type;
 }
-function pipeIssue(context, config, issue) {
-  const received = issue.received ?? stringify(issue.input);
-  const schemaIssue2 = {
-    reason: context.type,
-    context: issue.context.type,
-    expected: issue.context.expects,
-    received,
-    message: `Invalid ${issue.label}: ${issue.context.expects ? `Expected ${issue.context.expects} but r` : "R"}eceived ${received}`,
-    input: issue.input,
-    requirement: issue.context.requirement,
-    path: issue.path,
-    lang: config?.lang,
-    abortEarly: config?.abortEarly,
-    abortPipeEarly: config?.abortPipeEarly,
-    skipPipe: config?.skipPipe
-  };
-  schemaIssue2.message = i18n(
-    false,
-    issue.context,
-    issue.reference,
-    config,
-    schemaIssue2
-  );
-  return schemaIssue2;
-}
-function pipeResult(context, input, config, issues) {
-  if (context.pipe && !config?.skipPipe) {
-    for (const action of context.pipe) {
-      const result = action._parse(input);
-      if (result.issues) {
-        for (const actionIssue2 of result.issues) {
-          const schemaIssue2 = pipeIssue(context, config, actionIssue2);
-          issues ? issues.push(schemaIssue2) : issues = [schemaIssue2];
-        }
-        if (config?.abortEarly || config?.abortPipeEarly) {
-          break;
-        }
-      } else {
-        input = result.output;
-      }
-    }
-  }
-  return schemaResult(true, input, issues);
-}
-function restAndDefaultArgs(arg1, arg2, arg3) {
-  if (!arg1 || typeof arg1 === "object" && !Array.isArray(arg1)) {
-    const [error2, pipe2] = defaultArgs(arg2, arg3);
-    return [arg1, error2, pipe2];
-  }
-  const [error, pipe] = defaultArgs(
-    arg1,
-    arg2
-  );
-  return [void 0, error, pipe];
-}
-function schemaIssue(context, reference, input, config, other) {
-  const received = stringify(input);
-  const expected = other?.expected ?? context.expects;
+function _addIssue(context, label, dataset, config, other) {
+  const input = dataset.value;
+  const expected = context.expects;
+  const received = _stringify(input);
   const issue = {
-    reason: other?.reason ?? "type",
-    context: context.type,
+    kind: context.kind,
+    type: context.type,
+    input,
     expected,
     received,
-    message: `Invalid type: Expected ${expected} but received ${received}`,
-    input,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    // @ts-expect-error
+    requirement: context.requirement,
     path: other?.path,
     issues: other?.issues,
-    lang: config?.lang,
-    abortEarly: config?.abortEarly,
-    abortPipeEarly: config?.abortPipeEarly,
-    skipPipe: config?.skipPipe
+    lang: config.lang,
+    abortEarly: config.abortEarly,
+    abortPipeEarly: config.abortPipeEarly,
+    skipPipe: config.skipPipe
   };
-  issue.message = i18n(true, context, reference, config, issue);
-  return { typed: false, output: input, issues: [issue] };
+  const isSchema = context.kind === "schema";
+  const message = (
+    // @ts-expect-error
+    context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config.message ?? getGlobalMessage(issue.lang)
+  );
+  if (message) {
+    issue.message = typeof message === "function" ? message(issue) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
 }
-function getDefault(schema) {
-  return typeof schema.default === "function" ? schema.default() : schema.default;
+function getDefault(schema, dataset, config) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
 }
-function array(item, arg2, arg3) {
-  const [message, pipe] = defaultArgs(arg2, arg3);
+function array(item, message) {
   return {
+    kind: "schema",
     type: "array",
+    reference: array,
     expects: "Array",
     async: false,
     item,
     message,
-    pipe,
-    _parse(input, config) {
+    _run(dataset, config) {
+      const input = dataset.value;
       if (Array.isArray(input)) {
-        let typed = true;
-        let issues;
-        const output = [];
+        dataset.typed = true;
+        dataset.value = [];
         for (let key = 0; key < input.length; key++) {
           const value2 = input[key];
-          const result = this.item._parse(value2, config);
-          if (result.issues) {
+          const itemDataset = this.item._run({ typed: false, value: value2 }, config);
+          if (itemDataset.issues) {
             const pathItem = {
               type: "array",
               origin: "value",
@@ -319,57 +277,55 @@ function array(item, arg2, arg3) {
               key,
               value: value2
             };
-            for (const issue of result.issues) {
+            for (const issue of itemDataset.issues) {
               if (issue.path) {
                 issue.path.unshift(pathItem);
               } else {
                 issue.path = [pathItem];
               }
-              issues?.push(issue);
+              dataset.issues?.push(issue);
             }
-            if (!issues) {
-              issues = result.issues;
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
             }
-            if (config?.abortEarly) {
-              typed = false;
+            if (config.abortEarly) {
+              dataset.typed = false;
               break;
             }
           }
-          if (!result.typed) {
-            typed = false;
+          if (!itemDataset.typed) {
+            dataset.typed = false;
           }
-          output.push(result.output);
+          dataset.value.push(itemDataset.value);
         }
-        if (typed) {
-          return pipeResult(this, output, config, issues);
-        }
-        return schemaResult(false, output, issues);
+      } else {
+        _addIssue(this, "type", dataset, config);
       }
-      return schemaIssue(this, array, input, config);
+      return dataset;
     }
   };
 }
-function object(entries, arg2, arg3, arg4) {
-  const [rest, message, pipe] = restAndDefaultArgs(arg2, arg3, arg4);
-  let cachedEntries;
+function object(entries, message) {
   return {
+    kind: "schema",
     type: "object",
+    reference: object,
     expects: "Object",
     async: false,
     entries,
-    rest,
     message,
-    pipe,
-    _parse(input, config) {
-      if (input && typeof input === "object") {
-        cachedEntries = cachedEntries ?? Object.entries(this.entries);
-        let typed = true;
-        let issues;
-        const output = {};
-        for (const [key, schema] of cachedEntries) {
+    _run(dataset, config) {
+      const input = dataset.value;
+      if (input && typeof input === "object" && input.constructor === Object) {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
           const value2 = input[key];
-          const result = schema._parse(value2, config);
-          if (result.issues) {
+          const valueDataset = this.entries[key]._run(
+            { typed: false, value: value2 },
+            config
+          );
+          if (valueDataset.issues) {
             const pathItem = {
               type: "object",
               origin: "value",
@@ -377,111 +333,81 @@ function object(entries, arg2, arg3, arg4) {
               key,
               value: value2
             };
-            for (const issue of result.issues) {
+            for (const issue of valueDataset.issues) {
               if (issue.path) {
                 issue.path.unshift(pathItem);
               } else {
                 issue.path = [pathItem];
               }
-              issues?.push(issue);
+              dataset.issues?.push(issue);
             }
-            if (!issues) {
-              issues = result.issues;
+            if (!dataset.issues) {
+              dataset.issues = valueDataset.issues;
             }
-            if (config?.abortEarly) {
-              typed = false;
+            if (config.abortEarly) {
+              dataset.typed = false;
               break;
             }
           }
-          if (!result.typed) {
-            typed = false;
+          if (!valueDataset.typed) {
+            dataset.typed = false;
           }
-          if (result.output !== void 0 || key in input) {
-            output[key] = result.output;
-          }
-        }
-        if (this.rest && !(config?.abortEarly && issues)) {
-          for (const key in input) {
-            if (!(key in this.entries)) {
-              const value2 = input[key];
-              const result = this.rest._parse(value2, config);
-              if (result.issues) {
-                const pathItem = {
-                  type: "object",
-                  origin: "value",
-                  input,
-                  key,
-                  value: value2
-                };
-                for (const issue of result.issues) {
-                  if (issue.path) {
-                    issue.path.unshift(pathItem);
-                  } else {
-                    issue.path = [pathItem];
-                  }
-                  issues?.push(issue);
-                }
-                if (!issues) {
-                  issues = result.issues;
-                }
-                if (config?.abortEarly) {
-                  typed = false;
-                  break;
-                }
-              }
-              if (!result.typed) {
-                typed = false;
-              }
-              output[key] = result.output;
-            }
+          if (valueDataset.value !== void 0 || key in input) {
+            dataset.value[key] = valueDataset.value;
           }
         }
-        if (typed) {
-          return pipeResult(
-            this,
-            output,
-            config,
-            issues
-          );
-        }
-        return schemaResult(false, output, issues);
+      } else {
+        _addIssue(this, "type", dataset, config);
       }
-      return schemaIssue(this, object, input, config);
+      return dataset;
     }
   };
 }
-function optional(wrapped, default_) {
-  return {
+function optional(wrapped, ...args) {
+  const schema = {
+    kind: "schema",
     type: "optional",
+    reference: optional,
     expects: `${wrapped.expects} | undefined`,
     async: false,
     wrapped,
-    default: default_,
-    _parse(input, config) {
-      if (input === void 0) {
-        const override = getDefault(this);
-        if (override === void 0) {
-          return schemaResult(true, input);
+    _run(dataset, config) {
+      if (dataset.value === void 0) {
+        if ("default" in this) {
+          dataset.value = getDefault(
+            this,
+            dataset,
+            config
+          );
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
         }
-        input = override;
       }
-      return this.wrapped._parse(input, config);
+      return this.wrapped._run(dataset, config);
     }
   };
+  if (0 in args) {
+    schema.default = args[0];
+  }
+  return schema;
 }
-function string(arg1, arg2) {
-  const [message, pipe] = defaultArgs(arg1, arg2);
+function string(message) {
   return {
+    kind: "schema",
     type: "string",
+    reference: string,
     expects: "string",
     async: false,
     message,
-    pipe,
-    _parse(input, config) {
-      if (typeof input === "string") {
-        return pipeResult(this, input, config);
+    _run(dataset, config) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config);
       }
-      return schemaIssue(this, string, input, config);
+      return dataset;
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/shared",
-  "version": "1.5.12",
+  "version": "1.5.13-next.1",
   "description": "ESLint React's Shared constants and functions.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -35,12 +35,12 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "^7.9.0",
-    "deepmerge-ts": "5.1.0"
+    "@typescript-eslint/utils": "^7.10.0",
+    "deepmerge-ts": "7.0.0"
   },
   "devDependencies": {
     "type-fest": "4.18.2",
-    "valibot": "0.30.0"
+    "valibot": "0.31.0-rc.0"
   },
   "scripts": {
     "build": "tsup",