@eslint-react/shared 1.5.31-next.3 → 1.6.0-next.0

package/dist/index.mjs

@@ -223,9 +223,9 @@ function _stringify(input) {
   return type;
 }
 function _addIssue(context, label, dataset, config2, other) {
-  const input = dataset.value;
-  const expected = context.expects ?? null;
-  const received = _stringify(input);
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? _stringify(input);
   const issue = {
     kind: context.kind,
     type: context.type,
@@ -242,7 +242,7 @@ function _addIssue(context, label, dataset, config2, other) {
     abortPipeEarly: config2.abortPipeEarly
   };
   const isSchema = context.kind === "schema";
-  const message = // @ts-expect-error
+  const message = other?.message ?? // @ts-expect-error
   context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
   if (message) {
     issue.message = typeof message === "function" ? message(issue) : message;
@@ -458,6 +458,78 @@ function string(message) {
     }
   };
 }
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+function union(options, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: [...new Set(options.map((option) => option.expects))].join(" | ") || "never",
+    async: false,
+    options,
+    message,
+    _run(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema._run(
+          { typed: false, value: dataset.value },
+          config2
+        );
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
 function parse(schema, input, config2) {
   const dataset = schema._run(
     { typed: false, value: input },
@@ -487,32 +559,66 @@ var CustomAttributeSchema = object({
    */
   as: optional(string()),
   /**
-   * The default value of the attribute in the user-defined component.
-   * @example
-   * `"/"`
-   */
-  defaultValue: optional(string())
-});
-var CustomComponentSchema = object({
-  /**
-   * The name of the user-defined component.
+   * Whether the attribute is controlled or not in the user-defined component.
    * @example
-   * "Link"
+   * `true`
    */
-  name: string(),
+  controlled: optional(boolean()),
   /**
-   * The name of the built-in component that the user-defined component represents.
-   * @example
-   * "a"
-   */
-  as: string(),
-  /**
-   * Pre-defined attributes that are used in the user-defined component.
+   * The default value of the attribute in the user-defined component.
    * @example
-   * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
+   * `"/"`
    */
-  attributes: optional(array(CustomAttributeSchema))
+  defaultValue: optional(string())
 });
+var CustomComponentSchema = union([
+  object({
+    /**
+     * The name of the user-defined component.
+     * @example
+     * "Link"
+     */
+    name: string(),
+    /**
+     * The name of the built-in component that the user-defined component represents.
+     * @example
+     * "a"
+     */
+    as: optional(string()),
+    /**
+     * Pre-defined attributes that are used in the user-defined component.
+     * @example
+     * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
+     */
+    attributes: optional(array(CustomAttributeSchema))
+  }),
+  object({
+    /**
+     * The name of the user-defined component.
+     * @example
+     * "Link"
+     */
+    name: string(),
+    /**
+     * The ESQuery selector to select the component precisely.
+     * @example
+     * `:has(JSXAttribute[name.name='component'][value.value='a'])`
+     */
+    selector: string(),
+    /**
+     * The name of the built-in component that the user-defined component represents.
+     * @example
+     * "a"
+     */
+    as: string(),
+    /**
+     * Pre-defined attributes that are used in the user-defined component.
+     * @example
+     * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
+     */
+    attributes: optional(array(CustomAttributeSchema))
+  })
+]);
 var ESLintReactSettingsSchema = object({
   importSource: optional(string()),
   jsxPragma: optional(string()),
@@ -541,18 +647,319 @@ var ESLintReactSettingsSchema = object({
     useTransition: optional(array(string()))
   }))
 });
-var ESLintSettingsSchema = object({
-  "react-x": optional(ESLintReactSettingsSchema),
-  /**
-   * @deprecated
-   */
-  reactOptions: optional(ESLintReactSettingsSchema)
-});
+var ESLintSettingsSchema = optional(
+  object({
+    "react-x": optional(ESLintReactSettingsSchema, {}),
+    /**
+     * @internal
+     * @deprecated
+     */
+    reactOptions: optional(ESLintReactSettingsSchema, {})
+  }),
+  {}
+);
+
+// ../../node_modules/.pnpm/micro-memoize@4.1.2/node_modules/micro-memoize/dist/micro-memoize.esm.js
+var DEFAULT_OPTIONS_KEYS = {
+  isEqual: true,
+  isMatchingKey: true,
+  isPromise: true,
+  maxSize: true,
+  onCacheAdd: true,
+  onCacheChange: true,
+  onCacheHit: true,
+  transformKey: true
+};
+var slice = Array.prototype.slice;
+function cloneArray(arrayLike) {
+  var length = arrayLike.length;
+  if (!length) {
+    return [];
+  }
+  if (length === 1) {
+    return [arrayLike[0]];
+  }
+  if (length === 2) {
+    return [arrayLike[0], arrayLike[1]];
+  }
+  if (length === 3) {
+    return [arrayLike[0], arrayLike[1], arrayLike[2]];
+  }
+  return slice.call(arrayLike, 0);
+}
+function getCustomOptions(options) {
+  var customOptions = {};
+  for (var key in options) {
+    if (!DEFAULT_OPTIONS_KEYS[key]) {
+      customOptions[key] = options[key];
+    }
+  }
+  return customOptions;
+}
+function isMemoized(fn) {
+  return typeof fn === "function" && fn.isMemoized;
+}
+function isSameValueZero(object1, object2) {
+  return object1 === object2 || object1 !== object1 && object2 !== object2;
+}
+function mergeOptions(existingOptions, newOptions) {
+  var target = {};
+  for (var key in existingOptions) {
+    target[key] = existingOptions[key];
+  }
+  for (var key in newOptions) {
+    target[key] = newOptions[key];
+  }
+  return target;
+}
+var Cache = (
+  /** @class */
+  function() {
+    function Cache2(options) {
+      this.keys = [];
+      this.values = [];
+      this.options = options;
+      var isMatchingKeyFunction = typeof options.isMatchingKey === "function";
+      if (isMatchingKeyFunction) {
+        this.getKeyIndex = this._getKeyIndexFromMatchingKey;
+      } else if (options.maxSize > 1) {
+        this.getKeyIndex = this._getKeyIndexForMany;
+      } else {
+        this.getKeyIndex = this._getKeyIndexForSingle;
+      }
+      this.canTransformKey = typeof options.transformKey === "function";
+      this.shouldCloneArguments = this.canTransformKey || isMatchingKeyFunction;
+      this.shouldUpdateOnAdd = typeof options.onCacheAdd === "function";
+      this.shouldUpdateOnChange = typeof options.onCacheChange === "function";
+      this.shouldUpdateOnHit = typeof options.onCacheHit === "function";
+    }
+    Object.defineProperty(Cache2.prototype, "size", {
+      /**
+       * The number of cached [key,value] results.
+       */
+      get: function() {
+        return this.keys.length;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Cache2.prototype, "snapshot", {
+      /**
+       * A copy of the cache at a moment in time. This is useful
+       * to compare changes over time, since the cache mutates
+       * internally for performance reasons.
+       */
+      get: function() {
+        return {
+          keys: cloneArray(this.keys),
+          size: this.size,
+          values: cloneArray(this.values)
+        };
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Cache2.prototype._getKeyIndexFromMatchingKey = function(keyToMatch) {
+      var _a = this.options, isMatchingKey = _a.isMatchingKey, maxSize = _a.maxSize;
+      var keys = this.keys;
+      var keysLength = keys.length;
+      if (!keysLength) {
+        return -1;
+      }
+      if (isMatchingKey(keys[0], keyToMatch)) {
+        return 0;
+      }
+      if (maxSize > 1) {
+        for (var index = 1; index < keysLength; index++) {
+          if (isMatchingKey(keys[index], keyToMatch)) {
+            return index;
+          }
+        }
+      }
+      return -1;
+    };
+    Cache2.prototype._getKeyIndexForMany = function(keyToMatch) {
+      var isEqual = this.options.isEqual;
+      var keys = this.keys;
+      var keysLength = keys.length;
+      if (!keysLength) {
+        return -1;
+      }
+      if (keysLength === 1) {
+        return this._getKeyIndexForSingle(keyToMatch);
+      }
+      var keyLength = keyToMatch.length;
+      var existingKey;
+      var argIndex;
+      if (keyLength > 1) {
+        for (var index = 0; index < keysLength; index++) {
+          existingKey = keys[index];
+          if (existingKey.length === keyLength) {
+            argIndex = 0;
+            for (; argIndex < keyLength; argIndex++) {
+              if (!isEqual(existingKey[argIndex], keyToMatch[argIndex])) {
+                break;
+              }
+            }
+            if (argIndex === keyLength) {
+              return index;
+            }
+          }
+        }
+      } else {
+        for (var index = 0; index < keysLength; index++) {
+          existingKey = keys[index];
+          if (existingKey.length === keyLength && isEqual(existingKey[0], keyToMatch[0])) {
+            return index;
+          }
+        }
+      }
+      return -1;
+    };
+    Cache2.prototype._getKeyIndexForSingle = function(keyToMatch) {
+      var keys = this.keys;
+      if (!keys.length) {
+        return -1;
+      }
+      var existingKey = keys[0];
+      var length = existingKey.length;
+      if (keyToMatch.length !== length) {
+        return -1;
+      }
+      var isEqual = this.options.isEqual;
+      if (length > 1) {
+        for (var index = 0; index < length; index++) {
+          if (!isEqual(existingKey[index], keyToMatch[index])) {
+            return -1;
+          }
+        }
+        return 0;
+      }
+      return isEqual(existingKey[0], keyToMatch[0]) ? 0 : -1;
+    };
+    Cache2.prototype.orderByLru = function(key, value, startingIndex) {
+      var keys = this.keys;
+      var values = this.values;
+      var currentLength = keys.length;
+      var index = startingIndex;
+      while (index--) {
+        keys[index + 1] = keys[index];
+        values[index + 1] = values[index];
+      }
+      keys[0] = key;
+      values[0] = value;
+      var maxSize = this.options.maxSize;
+      if (currentLength === maxSize && startingIndex === currentLength) {
+        keys.pop();
+        values.pop();
+      } else if (startingIndex >= maxSize) {
+        keys.length = values.length = maxSize;
+      }
+    };
+    Cache2.prototype.updateAsyncCache = function(memoized) {
+      var _this = this;
+      var _a = this.options, onCacheChange = _a.onCacheChange, onCacheHit = _a.onCacheHit;
+      var firstKey = this.keys[0];
+      var firstValue = this.values[0];
+      this.values[0] = firstValue.then(function(value) {
+        if (_this.shouldUpdateOnHit) {
+          onCacheHit(_this, _this.options, memoized);
+        }
+        if (_this.shouldUpdateOnChange) {
+          onCacheChange(_this, _this.options, memoized);
+        }
+        return value;
+      }, function(error) {
+        var keyIndex = _this.getKeyIndex(firstKey);
+        if (keyIndex !== -1) {
+          _this.keys.splice(keyIndex, 1);
+          _this.values.splice(keyIndex, 1);
+        }
+        throw error;
+      });
+    };
+    return Cache2;
+  }()
+);
+function createMemoizedFunction(fn, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (isMemoized(fn)) {
+    return createMemoizedFunction(fn.fn, mergeOptions(fn.options, options));
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError("You must pass a function to `memoize`.");
+  }
+  var _a = options.isEqual, isEqual = _a === void 0 ? isSameValueZero : _a, isMatchingKey = options.isMatchingKey, _b = options.isPromise, isPromise = _b === void 0 ? false : _b, _c = options.maxSize, maxSize = _c === void 0 ? 1 : _c, onCacheAdd = options.onCacheAdd, onCacheChange = options.onCacheChange, onCacheHit = options.onCacheHit, transformKey = options.transformKey;
+  var normalizedOptions = mergeOptions({
+    isEqual,
+    isMatchingKey,
+    isPromise,
+    maxSize,
+    onCacheAdd,
+    onCacheChange,
+    onCacheHit,
+    transformKey
+  }, getCustomOptions(options));
+  var cache = new Cache(normalizedOptions);
+  var keys = cache.keys, values = cache.values, canTransformKey = cache.canTransformKey, shouldCloneArguments = cache.shouldCloneArguments, shouldUpdateOnAdd = cache.shouldUpdateOnAdd, shouldUpdateOnChange = cache.shouldUpdateOnChange, shouldUpdateOnHit = cache.shouldUpdateOnHit;
+  var memoized = function() {
+    var key = shouldCloneArguments ? cloneArray(arguments) : arguments;
+    if (canTransformKey) {
+      key = transformKey(key);
+    }
+    var keyIndex = keys.length ? cache.getKeyIndex(key) : -1;
+    if (keyIndex !== -1) {
+      if (shouldUpdateOnHit) {
+        onCacheHit(cache, normalizedOptions, memoized);
+      }
+      if (keyIndex) {
+        cache.orderByLru(keys[keyIndex], values[keyIndex], keyIndex);
+        if (shouldUpdateOnChange) {
+          onCacheChange(cache, normalizedOptions, memoized);
+        }
+      }
+    } else {
+      var newValue = fn.apply(this, arguments);
+      var newKey = shouldCloneArguments ? key : cloneArray(arguments);
+      cache.orderByLru(newKey, newValue, keys.length);
+      if (isPromise) {
+        cache.updateAsyncCache(memoized);
+      }
+      if (shouldUpdateOnAdd) {
+        onCacheAdd(cache, normalizedOptions, memoized);
+      }
+      if (shouldUpdateOnChange) {
+        onCacheChange(cache, normalizedOptions, memoized);
+      }
+    }
+    return values[0];
+  };
+  memoized.cache = cache;
+  memoized.fn = fn;
+  memoized.isMemoized = true;
+  memoized.options = normalizedOptions;
+  return memoized;
+}
 
 // src/settings.ts
-function parseESLintSettings(data) {
-  return parse(ESLintSettingsSchema, data);
+function decodeSettings(data) {
+  return parse(ESLintSettingsSchema, data)["react-x"] ?? {};
 }
+var expandSettings = createMemoizedFunction((settings) => {
+  if (Object.keys(settings).length === 0) return {};
+  return {
+    ...settings,
+    additionalComponents: settings.additionalComponents?.map((component) => ({
+      ...component,
+      attributes: component.attributes?.map((attr) => ({
+        ...attr,
+        as: attr.as ?? attr.name
+      })) ?? []
+    })) ?? []
+  };
+}, { isDeepEqual: false });
 var DEFAULT_ESLINT_REACT_SETTINGS = {
   additionalComponents: [
     {
@@ -574,4 +981,4 @@ var DEFAULT_ESLINT_REACT_SETTINGS = {
   version: "detect"
 };
 
-export { CustomAttributeSchema, CustomComponentSchema, CustomHookSchema, DEFAULT_ESLINT_REACT_SETTINGS, ESLintReactSettingsSchema, ESLintSettingsSchema, GITHUB_URL, HOST_HTML_COMPONENT_TYPES, HOST_SVG_COMPONENT_TYPES, NPM_SCOPE, RE_CAMEL_CASE, RE_CONSTANT_CASE, RE_JAVASCRIPT_PROTOCOL, RE_KEBAB_CASE, RE_PASCAL_CASE, RE_SNAKE_CASE, WEBSITE_URL, createRuleForPlugin, parseESLintSettings };
+export { CustomAttributeSchema, CustomComponentSchema, CustomHookSchema, DEFAULT_ESLINT_REACT_SETTINGS, ESLintReactSettingsSchema, ESLintSettingsSchema, GITHUB_URL, HOST_HTML_COMPONENT_TYPES, HOST_SVG_COMPONENT_TYPES, NPM_SCOPE, RE_CAMEL_CASE, RE_CONSTANT_CASE, RE_JAVASCRIPT_PROTOCOL, RE_KEBAB_CASE, RE_PASCAL_CASE, RE_SNAKE_CASE, WEBSITE_URL, createRuleForPlugin, decodeSettings, expandSettings };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/shared",
-  "version": "1.5.31-next.3",
+  "version": "1.6.0-next.0",
   "description": "ESLint React's Shared constants and functions.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -38,7 +38,8 @@
     "@typescript-eslint/utils": "^7.17.0"
   },
   "devDependencies": {
-    "tsup": "8.2.2",
+    "micro-memoize": "4.1.2",
+    "tsup": "8.2.3",
     "type-fest": "4.23.0",
     "valibot": "0.36.0"
   },