eslint-plugin-weld 0.0.4-rc.2 → 0.2.0

package/dist/index.js

@@ -1,22 +1,890 @@
 import { createRequire } from 'module';
+import createDebug from 'debug';
+import { existsSync } from 'fs';
+import path2 from 'path';
+import { getTsconfig } from 'get-tsconfig';
 
 // src/index.ts
+var PACKAGE_NAME = "eslint-plugin-weld";
+function createLogger(scope) {
+  return createDebug(`${PACKAGE_NAME}:${scope}`);
+}
+
+// src/imports/nodes.ts
+function isSpecifierNode(node) {
+  return node != null && node.type === "Literal" && typeof node.value === "string";
+}
+function createSpecifierVisitor(onSpecifier) {
+  return {
+    "ImportDeclaration, ImportExpression"(node) {
+      if (isSpecifierNode(node.source)) {
+        onSpecifier(node.source);
+      }
+    },
+    CallExpression(node) {
+      if (node.callee.type !== "Identifier" || node.callee.name !== "require") {
+        return;
+      }
+      const arg = node.arguments[0];
+      if (isSpecifierNode(arg)) {
+        onSpecifier(arg);
+      }
+    }
+  };
+}
+function replaceSpecifier(node, specifier) {
+  const quote = node.raw[0] ?? "'";
+  return (fixer) => fixer.replaceTextRange(node.range, `${quote}${specifier}${quote}`);
+}
+
+// src/extensions.ts
+var ENTRY_BASENAME = "index";
+var ENTRY_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"];
+var MODULE_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"];
+var ENTRY_EXTENSION_SET = new Set(ENTRY_EXTENSIONS);
+var MODULE_EXTENSION_SET = new Set(MODULE_EXTENSIONS);
+function isEntryExtension(ext) {
+  return ENTRY_EXTENSION_SET.has(ext);
+}
+function entryFileName(ext) {
+  return `${ENTRY_BASENAME}.${ext}`;
+}
+var ENTRY_FILE_NAMES = ENTRY_EXTENSIONS.map(entryFileName);
+function isEntryFileName(name, ext) {
+  return isEntryBasename(name) && isEntryExtension(ext);
+}
+function isEntryBasename(name) {
+  return name === ENTRY_BASENAME;
+}
+function isModuleExtension(ext) {
+  return MODULE_EXTENSION_SET.has(ext);
+}
+
+// src/path/posix.ts
+function toPosix(path3) {
+  return path3.replace(/\\/g, "/");
+}
+function segments(path3) {
+  return path3.split("/").filter(Boolean);
+}
+function joinSegments(segs) {
+  return segs.length === 0 ? "/" : `/${segs.join("/")}`;
+}
+function joinPath(dir, segment) {
+  return dir === "/" ? `/${segment}` : `${dir}/${segment}`;
+}
+function basename(path3) {
+  return path3.slice(path3.lastIndexOf("/") + 1);
+}
+function splitExtension(base) {
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1) {
+    return { name: base, ext: "" };
+  }
+  return { name: base.slice(0, dot), ext: base.slice(dot + 1) };
+}
+function dirname(path3) {
+  const segs = segments(path3);
+  if (segs.length === 0) {
+    return "/";
+  }
+  return joinSegments(segs.slice(0, -1));
+}
+function resolvePath(base, path3) {
+  const segs = path3.startsWith("/") ? [] : segments(base);
+  for (const part of path3.split("/")) {
+    if (part === "" || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      if (segs.length === 0) {
+        return null;
+      }
+      segs.pop();
+      continue;
+    }
+    segs.push(part);
+  }
+  return joinSegments(segs);
+}
+function commonPrefixLength(segsA, segsB) {
+  let i = 0;
+  while (i < segsA.length && i < segsB.length && segsA[i] === segsB[i]) {
+    i += 1;
+  }
+  return i;
+}
+function commonDepth(a, b) {
+  return commonPrefixLength(segments(a), segments(b));
+}
+function relativePath(from, to) {
+  const segsFrom = segments(from);
+  const segsTo = segments(to);
+  const i = commonPrefixLength(segsFrom, segsTo);
+  const ups = Array(segsFrom.length - i).fill("..");
+  const downs = segsTo.slice(i);
+  return [...ups, ...downs].join("/");
+}
+
+// src/imports/specifier.ts
+function parseSpecifier(specifier, fromDir, aliases) {
+  if (specifier.includes("?") || specifier.includes("!")) {
+    return null;
+  }
+  if (isRelativeSpecifier(specifier)) {
+    return finalize(resolvePath(fromDir, specifier), { kind: "relative" });
+  }
+  const alias = matchAlias(specifier, aliases);
+  if (alias !== null) {
+    const suffix = specifier.slice(alias.prefix.length).replace(/^\/+/, "");
+    return finalize(resolvePath(alias.anchor, suffix), { kind: "alias", alias });
+  }
+  return null;
+}
+function isRelativeSpecifier(specifier) {
+  return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function pickLongest(aliases, key) {
+  let best = null;
+  let bestLength = -1;
+  for (const alias of aliases) {
+    const matched = key(alias);
+    if (matched === null || matched.length <= bestLength) {
+      continue;
+    }
+    best = alias;
+    bestLength = matched.length;
+  }
+  return best;
+}
+function matchAlias(specifier, aliases) {
+  return pickLongest(aliases, (alias) => covers(alias.prefix, specifier) ? alias.prefix : null);
+}
+function finalize(path3, form) {
+  if (path3 === null) {
+    return null;
+  }
+  const { ext } = splitExtension(basename(path3));
+  if (ext !== "" && !isModuleExtension(ext)) {
+    return null;
+  }
+  return { path: path3, form, extension: ext === "" ? null : ext };
+}
+function renderSpecifier(form, fromDir, barrier, aliases, extension = null) {
+  const dir = renderDirectory(form, fromDir, barrier, aliases);
+  return extension === null ? dir : withEntry(dir, extension);
+}
+function renderDirectory(form, fromDir, barrier, aliases) {
+  if (form.kind === "relative") {
+    return renderRelative(fromDir, barrier);
+  }
+  if (covers(form.alias.anchor, barrier)) {
+    return renderAlias(form.alias, barrier);
+  }
+  const longest = longestCoveringAlias(aliases, barrier);
+  return longest === null ? renderRelative(fromDir, barrier) : renderAlias(longest, barrier);
+}
+function withEntry(dir, extension) {
+  const separator = dir.endsWith("/") ? "" : "/";
+  return `${dir}${separator}${entryFileName(extension)}`;
+}
+function covers(prefix, value) {
+  return value === prefix || value.startsWith(`${prefix}/`);
+}
+function longestCoveringAlias(aliases, dir) {
+  return pickLongest(aliases, (alias) => covers(alias.anchor, dir) ? alias.anchor : null);
+}
+function renderAlias(alias, barrier) {
+  if (barrier === alias.anchor) {
+    return alias.prefix;
+  }
+  return `${alias.prefix}/${relativePath(alias.anchor, barrier)}`;
+}
+function renderRelative(fromDir, barrier) {
+  const rel = relativePath(fromDir, barrier);
+  return rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
+}
+
+// src/settings/aliases.ts
+var debug = createLogger("aliases");
+function parseAliases(rawAliases, aliasesBaseUrl, source) {
+  if (typeof rawAliases !== "object" || rawAliases === null || Array.isArray(rawAliases)) {
+    throw new Error(`${source} must be an object`);
+  }
+  const base = resolvePath("/", aliasesBaseUrl) ?? "/";
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, rawValue] of Object.entries(rawAliases)) {
+    if (!hasValidStarShape(key)) {
+      debug('%s: dropped %s \u2014 key must have no "*" or end with "/*"', source, key);
+      continue;
+    }
+    const anchorsRaw = toAnchorList(key, rawValue, source);
+    const prefix = stripStarSuffix(key);
+    for (const anchorRaw of anchorsRaw) {
+      if (!hasValidStarShape(anchorRaw)) {
+        debug(
+          '%s: dropped %s -> %s \u2014 target must have no "*" or end with "/*"',
+          source,
+          key,
+          anchorRaw
+        );
+        continue;
+      }
+      const anchor = normalizeAnchor(anchorRaw, base);
+      if (anchor === null) {
+        debug(
+          "%s: dropped %s -> %s \u2014 not a directory (only index.<ext> stands for one) or above the repository root",
+          source,
+          key,
+          anchorRaw
+        );
+        continue;
+      }
+      const dedupeKey = `${prefix}\0${anchor}`;
+      if (seen.has(dedupeKey)) {
+        continue;
+      }
+      seen.add(dedupeKey);
+      result.push({ prefix, anchor });
+    }
+  }
+  if (debug.enabled) {
+    debug(
+      `${source} (aliasesBaseUrl ${aliasesBaseUrl}) resolved to:
+${formatAliases(result)}`
+    );
+  }
+  return result;
+}
+function formatAliases(aliases) {
+  if (aliases.length === 0) {
+    return "(none)";
+  }
+  return aliases.map(({ prefix, anchor }) => `${prefix} - ${anchor}`).join("\n");
+}
+function toAnchorList(key, value, source) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item !== "string") {
+        throw new Error(`${source}['${key}'] must contain only strings`);
+      }
+    }
+    return value;
+  }
+  throw new Error(`${source}['${key}'] must be a string or an array of strings`);
+}
+function hasValidStarShape(value) {
+  const starCount = value.split("*").length - 1;
+  if (starCount > 1 || starCount === 1 && !value.endsWith("/*")) {
+    return false;
+  }
+  return stripStarSuffix(value) !== "";
+}
+function stripStarSuffix(value) {
+  return value.endsWith("/*") ? value.slice(0, -2) : value;
+}
+function normalizeAnchor(anchorRaw, base) {
+  if (anchorRaw.endsWith("/*")) {
+    return resolvePath(base, anchorRaw.slice(0, -2));
+  }
+  const lastSegment = basename(anchorRaw);
+  const { name, ext } = splitExtension(lastSegment);
+  if (ext === "") {
+    return resolvePath(base, anchorRaw);
+  }
+  if (!isEntryFileName(name, ext)) {
+    return null;
+  }
+  return resolvePath(base, anchorRaw.slice(0, -lastSegment.length));
+}
+
+// src/settings/weld.ts
+var DEFAULT_ALIASES_BASE_URL = ".";
+function getWeldSettings(settings) {
+  if (typeof settings !== "object" || settings === null) {
+    return void 0;
+  }
+  const weld = settings.weld;
+  if (weld === void 0) {
+    return void 0;
+  }
+  if (typeof weld !== "object" || weld === null) {
+    throw new Error("settings.weld must be an object");
+  }
+  return weld;
+}
+function requireString(value, source) {
+  if (typeof value !== "string") {
+    throw new Error(`${source} must be a string, got ${typeof value}`);
+  }
+  return value;
+}
+function getRepoRoot(settings, override) {
+  if (override !== void 0) {
+    return requireString(override, "options.repoRoot");
+  }
+  const repoRoot = getWeldSettings(settings)?.repoRoot;
+  if (repoRoot === void 0) {
+    return void 0;
+  }
+  return requireString(repoRoot, "settings.weld.repoRoot");
+}
+function getAliasesBaseUrl(settings, override) {
+  if (override !== void 0) {
+    return requireString(override, "options.aliasesBaseUrl");
+  }
+  const aliasesBaseUrl = getWeldSettings(settings)?.aliasesBaseUrl;
+  if (aliasesBaseUrl === void 0) {
+    return DEFAULT_ALIASES_BASE_URL;
+  }
+  return requireString(aliasesBaseUrl, "settings.weld.aliasesBaseUrl");
+}
+function readAliases(settings, override, baseUrlOverride) {
+  const fromOverride = override !== void 0;
+  const rawAliases = fromOverride ? override : getWeldSettings(settings)?.aliases;
+  if (rawAliases === void 0) {
+    return [];
+  }
+  const source = fromOverride ? "options.aliases" : "settings.weld.aliases";
+  return parseAliases(rawAliases, getAliasesBaseUrl(settings, baseUrlOverride), source);
+}
+var TTL_MS = 6e4;
+var aliasesCache = [];
+function sameKey(left, right) {
+  return left[0] === right[0] && left[1] === right[1] && left[2] === right[2];
+}
+function cachedAliases(key, parse) {
+  const time = Date.now();
+  for (const entry of aliasesCache) {
+    if (entry.expiresAt > time && sameKey(entry.key, key)) {
+      return entry.result;
+    }
+  }
+  const result = parse();
+  aliasesCache = aliasesCache.filter(
+    (entry) => entry.expiresAt > time && !sameKey(entry.key, key)
+  );
+  aliasesCache.push({ key, result, expiresAt: time + TTL_MS });
+  return result;
+}
+function getAliases(settings, override, baseUrlOverride) {
+  return cachedAliases(
+    [settings, override, baseUrlOverride],
+    () => readAliases(settings, override, baseUrlOverride)
+  );
+}
+function getAliasesFromPaths(paths, virtualBase, source) {
+  return cachedAliases(
+    [paths, virtualBase, source],
+    () => parseAliases(paths, virtualBase, source)
+  );
+}
+function hasAliases(settings, override) {
+  if (override !== void 0) {
+    return true;
+  }
+  return getWeldSettings(settings)?.aliases !== void 0;
+}
+var DRIVE_PREFIX = /^[A-Za-z]:/;
+function isDriveRoot(realPath) {
+  return realPath.length === 2 && DRIVE_PREFIX.test(realPath);
+}
+function isAbsoluteRealPath(realPath) {
+  return realPath.startsWith("/") || DRIVE_PREFIX.test(realPath);
+}
+function normalizeRoot(root) {
+  const posix = toPosix(root);
+  if (posix === "/") {
+    return "";
+  }
+  return posix.endsWith("/") ? posix.slice(0, -1) : posix;
+}
+function joinReal(dir, name) {
+  return dir.endsWith("/") ? `${dir}${name}` : `${dir}/${name}`;
+}
+function parentOf(dir) {
+  const idx = dir.lastIndexOf("/");
+  if (idx === -1) {
+    return dir;
+  }
+  const head = dir.slice(0, idx);
+  if (head === "") {
+    return "/";
+  }
+  if (isDriveRoot(head)) {
+    return `${head}/`;
+  }
+  return head;
+}
+function sameSegment(left, right, index) {
+  if (index === 0 && DRIVE_PREFIX.test(left) && DRIVE_PREFIX.test(right)) {
+    return left.toUpperCase() === right.toUpperCase();
+  }
+  return left === right;
+}
+function commonRealDirectory(left, right) {
+  const prefixOf = (candidate) => DRIVE_PREFIX.exec(candidate)?.[0] ?? "";
+  const prefix = prefixOf(left);
+  const rightPrefix = prefixOf(right);
+  if (!sameSegment(prefix, rightPrefix, 0)) {
+    return null;
+  }
+  const leftRest = left.slice(prefix.length);
+  const depth = commonDepth(leftRest, right.slice(rightPrefix.length));
+  return `${prefix}${joinSegments(segments(leftRest).slice(0, depth))}`;
+}
+function resolveRealPath(base, target) {
+  const posixTarget = toPosix(target);
+  if (isAbsoluteRealPath(posixTarget)) {
+    return posixTarget;
+  }
+  const posixBase = toPosix(base);
+  const resolveBase = isDriveRoot(posixBase) ? `${posixBase}/` : posixBase;
+  const resolve = DRIVE_PREFIX.test(resolveBase) ? path2.win32.resolve : path2.posix.resolve;
+  return toPosix(resolve(resolveBase, posixTarget));
+}
+
+// src/host/root.ts
+var debug2 = createLogger("root");
+function findRepoRoot(startDir, exists) {
+  let current = toPosix(startDir);
+  let found = null;
+  debug2("searching repo root from %s", current);
+  for (; ; ) {
+    if (exists(joinReal(current, "package.json"))) {
+      found = current;
+      debug2("found package.json at %s", current);
+    }
+    if (exists(joinReal(current, ".git"))) {
+      debug2("found .git at %s, stopping", current);
+      break;
+    }
+    const parent = parentOf(current);
+    if (parent === current) {
+      debug2("reached filesystem root at %s", current);
+      break;
+    }
+    current = parent;
+  }
+  debug2("resolved repo root: %o", found);
+  return found;
+}
+
+// src/host/fs.ts
+var debug3 = createLogger("fs");
+var TTL_MS2 = 6e5;
+var NEGATIVE_TTL_MS = 5e3;
+function peek(cache2, key, time) {
+  const entry = cache2.get(key);
+  return entry !== void 0 && entry.expiresAt > time ? entry.value : void 0;
+}
+function remember(cache2, key, time, value) {
+  cache2.set(key, { value, expiresAt: time + (value ? TTL_MS2 : NEGATIVE_TTL_MS) });
+  return value;
+}
+function createFsHost(root, options = {}) {
+  const normalizedRoot = normalizeRoot(root);
+  const rootSegments = segments(normalizedRoot);
+  const now = options.now ?? Date.now;
+  const nativeExists = options.exists ?? existsSync;
+  const entryPointCache = /* @__PURE__ */ new Map();
+  const directoryCache = /* @__PURE__ */ new Map();
+  function toRealDir(dir) {
+    return `${normalizedRoot}${dir}`;
+  }
+  function toVirtual(realPath) {
+    const posixPath = toPosix(realPath);
+    if (!isAbsoluteRealPath(posixPath)) {
+      return null;
+    }
+    const pathSegments = segments(posixPath);
+    if (pathSegments.length < rootSegments.length) {
+      return null;
+    }
+    for (let i = 0; i < rootSegments.length; i += 1) {
+      if (!sameSegment(pathSegments[i], rootSegments[i], i)) {
+        return null;
+      }
+    }
+    return joinSegments(pathSegments.slice(rootSegments.length));
+  }
+  function directoryExists(dir) {
+    const time = now();
+    const cached = peek(directoryCache, dir, time);
+    if (cached !== void 0) {
+      return cached;
+    }
+    if (missingParent(dir, time)) {
+      return remember(directoryCache, dir, time, false);
+    }
+    const found = nativeExists(toRealDir(dir));
+    debug3("check directory %s: %o", dir, found);
+    return remember(directoryCache, dir, time, found);
+  }
+  function missingParent(dir, time) {
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return false;
+    }
+    return peek(directoryCache, parent, time) === false;
+  }
+  function hasEntryPoint(dir) {
+    if (!dir.startsWith("/")) {
+      return false;
+    }
+    const time = now();
+    const cached = peek(entryPointCache, dir, time);
+    if (cached !== void 0) {
+      return cached;
+    }
+    if (!directoryExists(dir)) {
+      return remember(entryPointCache, dir, time, false);
+    }
+    const realDir = toRealDir(dir);
+    const found = ENTRY_FILE_NAMES.some((name) => nativeExists(joinReal(realDir, name)));
+    debug3("check entry point %s: %o", dir, found);
+    return remember(entryPointCache, dir, time, found);
+  }
+  return { hasEntryPoint, toVirtual };
+}
+var instanceCache = /* @__PURE__ */ new Map();
+var repoRootCache = /* @__PURE__ */ new Map();
+function findRepoRootCached(cwd) {
+  const cached = repoRootCache.get(cwd);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const found = findRepoRoot(cwd, existsSync);
+  repoRootCache.set(cwd, found);
+  return found;
+}
+function resolveRoot(settings, cwd, repoRootOverride, coverDirs) {
+  const explicitRoot = getRepoRoot(settings, repoRootOverride);
+  if (explicitRoot !== void 0) {
+    return resolveRealPath(cwd, explicitRoot);
+  }
+  const base = toPosix(findRepoRootCached(cwd) ?? cwd);
+  let root = base;
+  for (const coverDir of coverDirs) {
+    const combined = commonRealDirectory(root, toPosix(coverDir));
+    if (combined === null) {
+      debug3(
+        "resolveRoot: cover dir %s shares no prefix with root %s, ignoring",
+        coverDir,
+        root
+      );
+      continue;
+    }
+    root = combined;
+  }
+  if (root !== base) {
+    debug3("resolveRoot: auto root raised from %s to %s to cover requested dirs", base, root);
+  }
+  return root;
+}
+function getFsHost(settings, cwd, repoRootOverride, coverDirs = []) {
+  const root = resolveRoot(settings, cwd, repoRootOverride, coverDirs);
+  const cached = instanceCache.get(root);
+  if (cached) {
+    return cached;
+  }
+  debug3("getFsHost: creating instance for root %s", root);
+  const created = createFsHost(root);
+  instanceCache.set(root, created);
+  return created;
+}
+var debug4 = createLogger("tsconfig");
+var TTL_MS3 = 6e5;
+var NEGATIVE_TTL_MS2 = 5e3;
+var cache = /* @__PURE__ */ new Map();
+function loadTsconfigPaths(realFilePath, options = {}) {
+  if (!path2.isAbsolute(realFilePath)) {
+    debug4("skip tsconfig lookup: file path is not absolute: %s", realFilePath);
+    return null;
+  }
+  const dir = path2.dirname(realFilePath);
+  const now = options.now ?? Date.now;
+  const time = now();
+  const entry = cache.get(dir);
+  if (entry && entry.expiresAt > time) {
+    return entry.value;
+  }
+  const readCache = /* @__PURE__ */ new Map();
+  const read = options.read ?? ((searchDir) => getTsconfig(searchDir, "tsconfig.json", readCache));
+  const value = readTsconfigPaths(dir, read);
+  cache.set(dir, { value, expiresAt: time + (value ? TTL_MS3 : NEGATIVE_TTL_MS2) });
+  return value;
+}
+function readTsconfigPaths(dir, read) {
+  let found;
+  try {
+    found = read(dir);
+  } catch (error) {
+    debug4("failed to read tsconfig near %s: %s", dir, error);
+    return null;
+  }
+  if (!found) {
+    debug4("no tsconfig found upwards from %s", dir);
+    return null;
+  }
+  const configPath = found.path;
+  const compilerOptions = found.config.compilerOptions ?? {};
+  const paths = compilerOptions["paths"];
+  if (typeof paths !== "object" || paths === null || Object.keys(paths).length === 0) {
+    debug4("tsconfig %s has no compilerOptions.paths", configPath);
+    return null;
+  }
+  const baseUrl = typeof compilerOptions["baseUrl"] === "string" ? compilerOptions["baseUrl"] : void 0;
+  const realBaseDir = baseUrl !== void 0 ? path2.resolve(path2.dirname(configPath), baseUrl) : getImplicitBaseUrl(compilerOptions) ?? path2.dirname(configPath);
+  const record = relativizePathsValues(paths, realBaseDir);
+  debug4("found paths in %s, base dir %s", configPath, realBaseDir);
+  return {
+    paths: record,
+    realBaseDir,
+    configPath,
+    realAnchors: collectRealAnchors(record, realBaseDir)
+  };
+}
+function getImplicitBaseUrl(compilerOptions) {
+  const symbol = Object.getOwnPropertySymbols(compilerOptions).find(
+    (candidate) => candidate.description === "implicitBaseUrl"
+  );
+  const value = symbol === void 0 ? void 0 : compilerOptions[symbol];
+  return typeof value === "string" ? value : void 0;
+}
+var ABSOLUTE_REAL_PATH = /^(?:\/|[A-Za-z]:)/;
+function relativizePathsValues(paths, realBaseDir) {
+  const relativize = (item) => {
+    if (typeof item !== "string" || !ABSOLUTE_REAL_PATH.test(item)) {
+      return item;
+    }
+    const relative = toPosix(path2.relative(realBaseDir, item));
+    if (relative === "") {
+      return ".";
+    }
+    return relative.startsWith("*") ? `./${relative}` : relative;
+  };
+  const result = {};
+  for (const [key, value] of Object.entries(paths)) {
+    result[key] = Array.isArray(value) ? value.map(relativize) : relativize(value);
+  }
+  return result;
+}
+function collectRealAnchors(paths, realBaseDir) {
+  const anchors = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(paths)) {
+    if (!hasValidStarShape(key)) {
+      continue;
+    }
+    const items = Array.isArray(value) ? value : [value];
+    for (const item of items) {
+      if (typeof item !== "string" || !hasValidStarShape(item)) {
+        continue;
+      }
+      const anchor = path2.resolve(realBaseDir, stripStarSuffix(item));
+      if (segments(toPosix(anchor)).includes("node_modules")) {
+        debug4("anchor %s is inside node_modules, excluded from root computation", anchor);
+        continue;
+      }
+      anchors.add(anchor);
+    }
+  }
+  return [...anchors];
+}
+
+// src/rules/context.ts
+var debug5 = createLogger("rules");
+var WELD_OPTION_PROPERTIES = {
+  repoRoot: { type: "string" },
+  aliasesBaseUrl: { type: "string" },
+  aliases: { type: "object" }
+};
+function resolveWeldContext(context, fsHostOverride) {
+  const options = context.options[0] ?? {};
+  const { fsHost, aliases } = resolveHostAndAliases(context, options, fsHostOverride);
+  const fromFile = fsHost.toVirtual(context.filename);
+  if (fromFile === null) {
+    return null;
+  }
+  return { fromFile, aliases, fsHost, options };
+}
+function resolveHostAndAliases(context, options, fsHostOverride) {
+  if (hasAliases(context.settings, options.aliases)) {
+    return {
+      fsHost: fsHostOverride ?? getFsHost(context.settings, context.cwd, options.repoRoot),
+      aliases: getAliases(context.settings, options.aliases, options.aliasesBaseUrl)
+    };
+  }
+  const found = loadTsconfigPaths(context.filename);
+  const hasExplicitRoot = getRepoRoot(context.settings, options.repoRoot) !== void 0;
+  const fsHost = getFsHost(
+    context.settings,
+    context.cwd,
+    options.repoRoot,
+    found?.realAnchors ?? []
+  );
+  return { fsHost, aliases: aliasesFromTsconfig(found, fsHost, hasExplicitRoot) };
+}
+function aliasesFromTsconfig(found, fsHost, hasExplicitRoot) {
+  if (found === null) {
+    return [];
+  }
+  if (hasExplicitRoot && fsHost.toVirtual(found.configPath) === null) {
+    debug5("discarding tsconfig %s: it is outside the explicit root", found.configPath);
+    return [];
+  }
+  const virtualBase = fsHost.toVirtual(found.realBaseDir);
+  if (virtualBase === null) {
+    debug5(
+      "discarding tsconfig %s: base dir %s is outside the root",
+      found.configPath,
+      found.realBaseDir
+    );
+    return [];
+  }
+  try {
+    return getAliasesFromPaths(found.paths, virtualBase, found.configPath);
+  } catch (error) {
+    debug5("discarding tsconfig %s: %s", found.configPath, error);
+    return [];
+  }
+}
+
+// src/rules/no-barrel-bypass/core/barrier.ts
+function isIndexFile(targetPath) {
+  return isEntryBasename(splitExtension(basename(targetPath)).name);
+}
+function findBarrier(fromDir, targetPath, hasEntryPoint) {
+  const targetDir = dirname(targetPath);
+  const targetDirSegments = segments(targetDir);
+  const depth = commonDepth(fromDir, targetDir);
+  let dir = joinSegments(targetDirSegments.slice(0, depth));
+  for (let i = depth; i < targetDirSegments.length; i += 1) {
+    dir = joinPath(dir, targetDirSegments[i]);
+    if (hasEntryPoint(dir)) {
+      const atTargetDir = i === targetDirSegments.length - 1;
+      return atTargetDir && isIndexFile(targetPath) ? null : dir;
+    }
+  }
+  return null;
+}
+
+// src/rules/no-barrel-bypass/pipeline.ts
+var debug6 = createLogger("no-barrel-bypass");
+function createChecker({ fromFile, aliases }, host) {
+  const fromDir = dirname(fromFile);
+  return function checkImport(specifier) {
+    const target = parseSpecifier(specifier, fromDir, aliases);
+    if (target === null) {
+      debug6("%s: %s external dependency", fromFile, specifier);
+      return null;
+    }
+    const barrier = findBarrier(fromDir, target.path, host.hasEntryPoint);
+    if (barrier === null) {
+      debug6("%s: %s -> %s, no barrier on the way", fromFile, specifier, target.path);
+      return null;
+    }
+    return renderSpecifier(target.form, fromDir, barrier, aliases, target.extension);
+  };
+}
+
+// src/rules/no-barrel-bypass/index.ts
+var debug7 = createLogger("no-barrel-bypass");
+var messages = {
+  bypass: "Import bypasses the module barrel. Use '{{suggestion}}' instead of '{{original}}'.",
+  useBarrel: "Import through '{{suggestion}}'."
+};
+function createRule(fsHost) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "disallow imports that reach into a module past its barrel",
+        url: "https://github.com/jt4d-lab/weld/blob/master/docs/rules/no-barrel-bypass.md"
+      },
+      fixable: "code",
+      hasSuggestions: true,
+      schema: [
+        {
+          type: "object",
+          properties: {
+            fix: { type: "boolean" },
+            ...WELD_OPTION_PROPERTIES
+          },
+          additionalProperties: false
+        }
+      ],
+      messages
+    },
+    create(context) {
+      const weld = resolveWeldContext(context, fsHost);
+      if (weld === null) {
+        return {};
+      }
+      const { fromFile } = weld;
+      const applyFix = weld.options.fix ?? true;
+      const checkImport = createChecker(weld, weld.fsHost);
+      return createSpecifierVisitor((sourceNode) => {
+        const original = sourceNode.value;
+        const suggestion = checkImport(original);
+        if (suggestion === null) {
+          return;
+        }
+        debug7(
+          "%s: crosses barrier, %s -> %s (fix=%o)",
+          fromFile,
+          original,
+          suggestion,
+          applyFix
+        );
+        const fix = replaceSpecifier(sourceNode, suggestion);
+        context.report({
+          node: sourceNode,
+          messageId: "bypass",
+          data: { suggestion, original },
+          ...applyFix ? { fix } : { suggest: [{ messageId: "useBarrel", data: { suggestion }, fix }] }
+        });
+      });
+    }
+  };
+}
 
 // src/rules/index.ts
-var rules = {};
+var rules = {
+  "no-barrel-bypass": createRule()
+};
 
 // src/index.ts
-var { name, version } = createRequire(import.meta.url)("../package.json");
+var { version } = createRequire(import.meta.url)("../package.json");
 var recommended = {
   name: "weld/recommended",
-  rules: {}
+  rules: {
+    "weld/no-barrel-bypass": "error"
+  }
+};
+var strict = {
+  name: "weld/strict",
+  rules: {
+    "weld/no-barrel-bypass": "error"
+  }
 };
 var plugin = {
-  meta: { name, version },
+  meta: {
+    name: PACKAGE_NAME,
+    version
+  },
   rules,
-  configs: { recommended }
+  configs: {
+    recommended,
+    strict
+  }
 };
 recommended.plugins = { weld: plugin };
+strict.plugins = { weld: plugin };
 var index_default = plugin;
 
 export { index_default as default };