@jskit-ai/jskit-catalog 0.2.45 → 0.2.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-catalog",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "description": "Published metadata catalog for JSKIT package metadata.",
   "type": "module",
   "files": [

package/scripts/data-access-files.mjs

@@ -18,6 +18,7 @@ const ROOT = String.raw`(?:(?:packages|tooling)/[^/]+/)?`;
 const SERVER_FILE = new RegExp(`^${ROOT}(?:[^/]+$|(?:src|server|scripts|bin|config)/)`, "u");
 const FRAMEWORK_DIRECTORY = path.join("node_modules", "@jskit-ai");
 const SOURCE_FILE = /\.[cm]?js$/u;
+const VUE_FILE = /\.vue$/u;
 const SKIPPED_FILE = /\.(?:test|spec|vitest)\.[cm]?js$/u;
 // Code that defines no table resource or system scope an app runs: dependencies, anywhere; and, at a root (ROOT), build
 // output, tests and fixtures, migrations and seeds, and the examples, templates and documentation JSKIT packages carry.
@@ -29,7 +30,7 @@ const PACKAGE_DIRECTORY = /^(?:packages|tooling)\/[^/]+\/(.+)$/u;
 const skipsDirectory = (name) => path.posix.basename(name) === "node_modules" ||
   SKIPPED_ROOT_DIRECTORIES.has(PACKAGE_DIRECTORY.exec(name)?.[1] ?? name);
 
-async function walk(root, directory, files) {
+async function walk(root, directory, files, pattern = SOURCE_FILE) {
   let entries;
   try {
     entries = await readdir(path.join(root, directory), { withFileTypes: true });
@@ -40,8 +41,8 @@ async function walk(root, directory, files) {
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
     const relative = directory ? path.join(directory, entry.name) : entry.name;
     if (entry.isDirectory()) {
-      if (!entry.name.startsWith(".") && !skipsDirectory(toPosixPath(relative))) await walk(root, relative, files);
-    } else if (entry.isFile() && SOURCE_FILE.test(entry.name) && !SKIPPED_FILE.test(entry.name)) {
+      if (!entry.name.startsWith(".") && !skipsDirectory(toPosixPath(relative))) await walk(root, relative, files, pattern);
+    } else if (entry.isFile() && pattern.test(entry.name) && !SKIPPED_FILE.test(entry.name)) {
       files.push(relative);
     }
   }
@@ -68,8 +69,12 @@ async function frameworkPackages(root) {
   return packages;
 }
 
-// The app's ESLint, from the app or else beside this check, set to find each file's config as `eslint` does; null when
-// neither has one, or the app has no config: then the lint itself cannot run, which fails on its own.
+// A file directly in a directory, for asking ESLint about the directory: its API judges files, not directories.
+const DIRECTORY_PROBE = "jskit-directory-probe.js";
+
+// The app's ESLint, from the app or else beside this check, set to find each file's config as `eslint` does, with
+// its ESLint class; null when neither has one, or the app has no config: then the lint itself cannot run, which fails
+// on its own.
 async function appEslint(root) {
   for (const base of [path.join(root, "package.json"), fileURLToPath(import.meta.url)]) {
     let resolved;
@@ -79,25 +84,58 @@ async function appEslint(root) {
       continue;
     }
     const api = await import(pathToFileURL(resolved).href);
-    const eslint = new (api.ESLint || api.default.ESLint)({ cwd: root });
-    return await eslint.findConfigFile(path.join(root, "package.json")) ? eslint : null;
+    const { ESLint } = api.ESLint ? api : api.default;
+    const eslint = new ESLint({ cwd: root });
+    return await eslint.findConfigFile(path.join(root, "package.json")) ? { eslint, ESLint } : null;
   }
   return null;
 }
 
-// The ESLint config of each app file that one governs, read as `eslint` reads it: each { file, governed, config },
-// `governed` the file's path from that config's directory and `config` undefined when the config ignores the file; and the
-// first error reading one, after which no more are read. None when the app has no ESLint config (appEslint).
+// For a config file, the config whose ignores keep `eslint .`, run at the app's root, out of its directory; undefined
+// when it enters it. ESLint enters a directory unless the config of the directory above ignores it, so a parent config
+// ignores a nested config's directory whole, and past it the nested config alone judges what it holds. The directory's
+// verdict is that of a file directly in it, asked of an ESLint bound to the config above alone.
+function configIgnoredBy(root, { eslint, ESLint }) {
+  const verdicts = new Map();
+  const bound = new Map();
+  const boundTo = (configFile) => {
+    if (!bound.has(configFile)) bound.set(configFile, new ESLint({ cwd: path.dirname(configFile), overrideConfigFile: configFile }));
+    return bound.get(configFile);
+  };
+  async function verdict(configFile) {
+    const directory = path.dirname(configFile);
+    const inside = path.relative(root, directory);
+    if (!inside || inside.startsWith("..") || path.isAbsolute(inside)) return undefined;
+    // The config of the directory above, which ESLint asks before entering this one.
+    const above = await eslint.findConfigFile(directory);
+    if (!above) return undefined;
+    return await ignoredBy(above) ??
+      (await boundTo(above).isPathIgnored(path.join(directory, DIRECTORY_PROBE)) ? above : undefined);
+  }
+  function ignoredBy(configFile) {
+    if (!verdicts.has(configFile)) verdicts.set(configFile, verdict(configFile));
+    return verdicts.get(configFile);
+  }
+  return ignoredBy;
+}
+
+// The ESLint config of each app file that one governs, read as `eslint .` reads it: each { file, governed, config },
+// `governed` the file's path from that config's directory and `config` undefined when the config ignores the file, or
+// when a config above ignores the directory of the file's nested config (configIgnoredBy), as `eslint .` never reaches
+// it: `governed` is then told from the directory of the config that ignores it. And the first error reading one, after
+// which no more are read. None when the app has no ESLint config (appEslint).
 async function lintConfigs(root, files) {
   const configs = [];
-  const eslint = await appEslint(root);
-  for (const file of eslint ? files : []) {
+  const app = await appEslint(root);
+  const ignoredBy = app && configIgnoredBy(root, app);
+  for (const file of app ? files : []) {
     const absolute = path.join(root, file);
     try {
-      const configFile = await eslint.findConfigFile(absolute);
+      const configFile = await app.eslint.findConfigFile(absolute);
       if (!configFile) continue;
-      const governed = toPosixPath(path.relative(path.dirname(configFile), absolute));
-      configs.push({ file, governed, config: await eslint.calculateConfigForFile(absolute) });
+      const outer = await ignoredBy(configFile);
+      const governed = toPosixPath(path.relative(path.dirname(outer ?? configFile), absolute));
+      configs.push({ file, governed, config: outer ? undefined : await app.eslint.calculateConfigForFile(absolute) });
     } catch (error) {
       return { configs, error: { file, message: String(error?.message || error).split("\n")[0] } };
     }
@@ -137,4 +175,11 @@ async function sourceFiles(root) {
   return { sources, lint, skipped: skippedPaths(names, skipped) };
 }
 
-export { ROOT, lintIgnores, sourceFiles };
+// The app's own Vue components, which data/search-q reads for the list screens they show.
+async function vueFiles(root) {
+  const files = [];
+  await walk(root, "", files, VUE_FILE);
+  return files.map((file) => ({ file: toPosixPath(file), absolute: path.join(root, file) }));
+}
+
+export { ROOT, lintIgnores, sourceFiles, vueFiles };

package/scripts/data-access-source.mjs

@@ -0,0 +1,169 @@
+import { blankJsComments, lineIndex } from "./material3-source.mjs";
+
+// JavaScript source read as `jskit check`'s data part reads it, never run: the code with its comments blanked, a masked
+// copy with the contents of its strings blanked too, every offset kept, and the object literals, keys and literal values
+// found in them.
+
+const blank = (text) => text.replace(/[^\n]/gu, " ");
+
+// Code with its comments and the contents of its strings and templates blanked to spaces, every offset kept: calls
+// and keys are found in it, values are read from the code at the same offsets.
+function maskStrings(code) {
+  let output = "";
+  let index = 0;
+  while (index < code.length) {
+    const quote = code[index];
+    if (quote !== "\"" && quote !== "'" && quote !== "`") {
+      output += quote;
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < code.length && code[end] !== quote && (quote === "`" || code[end] !== "\n")) {
+      end += code[end] === "\\" ? 2 : 1;
+    }
+    output += quote + blank(code.slice(index + 1, end)) + code.slice(end, end + 1);
+    index = end + 1;
+  }
+  return output;
+}
+
+// The offset just past the bracket that closes the one at `start`, in masked code; -1 when it never closes.
+function closingOffset(masked, start) {
+  let depth = 0;
+  for (let index = start; index < masked.length; index += 1) {
+    if ("([{".includes(masked[index])) depth += 1;
+    else if (")]}".includes(masked[index]) && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+
+const nextCodeOffset = (text, offset) => offset + (/^\s*/u.exec(text.slice(offset))?.[0].length || 0);
+
+// The string a top-level `const NAME = "..."` gives, or null.
+function constantValue(code, name) {
+  const match = new RegExp(`(?:^|[\\s;])const\\s+${name}\\s*=\\s*(["'\`])((?:\\\\.|(?!\\1)[^\\\\\\n])*)\\1\\s*[;,\\n]`, "u").exec(code);
+  return match && !(match[1] === "`" && match[2].includes("${")) ? match[2] : null;
+}
+
+/**
+ * The value written at an offset, read up to the comma or bracket that ends it: { text } for a string literal, a
+ * template without expressions, or a const holding one; { text: null } for anything else.
+ */
+function readValue(code, masked, offset) {
+  const start = nextCodeOffset(code, offset);
+  const quote = code[start];
+  if (quote === "\"" || quote === "'" || quote === "`") {
+    let end = start + 1;
+    while (end < code.length && code[end] !== quote) end += code[end] === "\\" ? 2 : 1;
+    const after = masked[nextCodeOffset(masked, end + 1)];
+    const text = code.slice(start + 1, end);
+    const whole = after === "," || after === "}" || after === ")";
+    return { text: whole && !(quote === "`" && text.includes("${")) ? text.replace(/\\(.)/gu, "$1") : null };
+  }
+  const identifier = /^[A-Za-z_$][\w$]*(?=\s*[,})])/u.exec(code.slice(start));
+  return { text: identifier ? constantValue(code, identifier[0]) : null };
+}
+
+// The top-level keys of the object literal between `start` and `end`, in masked code: for each wanted key, the offset
+// just past its colon, or "shorthand" for `{ name }`.
+function topLevelKeys(masked, start, end, names) {
+  let depth = 0;
+  let top = "";
+  for (let index = start; index < end; index += 1) {
+    const char = masked[index];
+    if ("([{".includes(char)) depth += 1;
+    top += depth === 1 || char === "\n" ? char : " ";
+    if (")]}".includes(char)) depth -= 1;
+  }
+  const keys = new Map();
+  for (const match of top.matchAll(/(?:^|[{,])\s*([A-Za-z_$][\w$]*)\s*(:|(?=[,}]))/gu)) {
+    const [whole, key, colon] = match;
+    if (names.includes(key) && !keys.has(key)) keys.set(key, colon ? start + match.index + whole.length : "shorthand");
+  }
+  return keys;
+}
+
+// The object literal a call at `callOffset` takes as its first argument: { start, end } in masked code, or null when the
+// call is a declaration (`function defineFeature(`) or its first argument is anything else.
+function objectArgument(masked, callOffset, matchLength) {
+  if (/function\s*\*?\s*$/u.test(masked.slice(Math.max(0, callOffset - 20), callOffset))) return null;
+  const start = nextCodeOffset(masked, callOffset + matchLength);
+  if (masked[start] !== "{") return null;
+  const end = closingOffset(masked, start);
+  return end < 0 ? null : { start, end };
+}
+
+// The value of one key of an object literal, as readValue reads it; undefined when the object has no such key.
+function keyValue(code, masked, keys, key) {
+  const at = keys.get(key);
+  if (at === undefined) return undefined;
+  return at === "shorthand" ? { text: constantValue(code, key) } : readValue(code, masked, at);
+}
+
+function readSourceFile(source) {
+  const code = blankJsComments(source);
+  return { source, code, masked: maskStrings(code), position: lineIndex(source) };
+}
+
+// Every key of the object literal between `start` and `end` (masked code), in order, and whether the literal also
+// spreads or computes keys, so that its keys are not all known.
+function objectKeys(masked, start, end) {
+  let depth = 0;
+  let top = "";
+  for (let index = start; index < end; index += 1) {
+    const char = masked[index];
+    if ("([{".includes(char)) depth += 1;
+    top += depth === 1 || char === "\n" ? char : " ";
+    if (")]}".includes(char)) depth -= 1;
+  }
+  const keys = [...top.matchAll(/(?:^|[{,])\s*([A-Za-z_$][\w$]*)\s*(?::|(?=[,}]))/gu)].map((match) => ({
+    key: match[1],
+    at: start + match.index + match[0].length
+  }));
+  return { keys, partial: /(?:^|[{,])\s*(?:\.\.\.|["'`[])/u.test(top) };
+}
+
+// The object literal written at an offset: { start, end } in masked code, or null for anything else.
+function objectAt(masked, offset) {
+  const start = nextCodeOffset(masked, offset);
+  if (masked[start] !== "{") return null;
+  const end = closingOffset(masked, start);
+  return end < 0 ? null : { start, end };
+}
+
+// The variable a declaration just before an offset assigns: `const name = ` ends the text before it.
+const assignedVariable = (masked, offset) =>
+  /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*$/u.exec(masked.slice(Math.max(0, offset - 120), offset))?.[1] ?? null;
+
+// The identifier written at an offset, or null.
+const identifierAt = (code, offset) => /^\s*([A-Za-z_$][\w$]*)\s*[,})]/u.exec(code.slice(offset))?.[1] ?? null;
+
+// The object literal around an offset, in masked code: { start, end }, or null when the offset is in none.
+function enclosingObject(masked, offset) {
+  let depth = 0;
+  for (let index = offset - 1; index >= 0; index -= 1) {
+    if (")]}".includes(masked[index])) depth += 1;
+    else if ("([{".includes(masked[index]) && depth-- === 0) {
+      const end = masked[index] === "{" ? closingOffset(masked, index) : -1;
+      return end < 0 ? null : { start: index, end };
+    }
+  }
+  return null;
+}
+
+export {
+  assignedVariable,
+  blank,
+  closingOffset,
+  enclosingObject,
+  identifierAt,
+  keyValue,
+  nextCodeOffset,
+  objectArgument,
+  objectAt,
+  objectKeys,
+  readSourceFile,
+  readValue,
+  topLevelKeys
+};