@navecss/core 0.1.1 → 0.3.0

package/dist/atomic.css

@@ -191,7 +191,9 @@
     outline: none;
 
     &:focus-visible {
-      outline: var(--nave-border-width-focus) solid var(--nave-color-border-focus);
+      outline-style: solid;
+      outline-width: var(--nave-border-width-focus, 2px);
+      outline-color: var(--nave-color-border-focus, currentColor);
       outline-offset: 2px;
     }
   }

package/dist/atoms.d.ts

@@ -208,6 +208,10 @@ declare const atoms: {
     /**
      * focusRing — keyboard focus indicator.
      * :focus-visible — keyboard users see it, mouse users do not.
+     *
+     * Longhands with fallbacks, not an `outline` shorthand, which computes to `none` as a whole when
+     * a `var()` in it has no usable value: no token layer, a missing property, or a wrong-typed value
+     * in an unregistered property. The fallbacks are 2px and `currentColor`, never a literal colour.
      */
     readonly focusRing: {
         readonly declarations: {
@@ -215,7 +219,9 @@ declare const atoms: {
         };
         readonly pseudos: {
             readonly ':focus-visible': {
-                readonly outline: "var(--nave-border-width-focus) solid var(--nave-color-border-focus)";
+                readonly 'outline-style': "solid";
+                readonly 'outline-width': "var(--nave-border-width-focus, 2px)";
+                readonly 'outline-color': "var(--nave-color-border-focus, currentColor)";
                 readonly 'outline-offset': "2px";
             };
         };
@@ -405,7 +411,7 @@ type AtomName = keyof typeof atoms;
 declare const toClassName: (name: AtomName) => string;
 /**
  * Map of atom name → global CSS class name.
- * Used by cx() and the PostCSS plugin.
+ * Used by cx() and the directive core's diagnostic hints.
  * Only covers Nave built-in atoms — consumer atoms are @nave-directive only.
  */
 declare const atomClassMap: Record<AtomName, string>;

package/dist/atoms.js

@@ -1 +1 @@
-export { atomClassMap, atoms, toClassName } from './chunk-BVON7XKC.js';
+export { atomClassMap, atoms, toClassName } from './chunk-LIUB4EES.js';

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+import { runCheck } from './chunk-XQQCDUV6.js';
+import { splitByteOrderMark, foldedText } from './chunk-IZQLFUQU.js';
+import { formatFinding } from './chunk-UANF3FGO.js';
+import { validateExtendAtomsHostFree } from './chunk-R6JJZGXC.js';
+import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
+import { snapshotExtendMap, expandText } from './chunk-S7DZUVV3.js';
+import { createPositionFinder, tokenize, atKeywordName } from './chunk-NFS2REPQ.js';
+import './chunk-LIUB4EES.js';
+import { parseArgs } from 'util';
+import { realpathSync, watch, existsSync, statSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import path2 from 'path';
+
+// src/bin-usage.ts
+var USAGE = `Usage:
+  navecss-core check --source=<file-or-dir> [--source=<file-or-dir> ...]
+  navecss-core expand --source=<file> --out=<file> [--source=<file> --out=<file> ...] [--extend=<module>] [--watch]`;
+function readValues(args) {
+  try {
+    const { values, positionals } = parseArgs({
+      args: [...args],
+      options: {
+        extend: { type: "string", multiple: true },
+        out: { type: "string", multiple: true },
+        source: { type: "string", multiple: true },
+        watch: { type: "boolean" }
+      },
+      strict: true,
+      allowPositionals: true
+    });
+    if (positionals.length > 0) {
+      return `expand does not take a positional argument: ${positionals[0]}`;
+    }
+    if ((values.extend?.length ?? 0) > 1) return "expand takes one --extend.";
+    return {
+      extend: values.extend?.[0],
+      out: values.out ?? [],
+      source: values.source ?? [],
+      watch: values.watch === true
+    };
+  } catch (error) {
+    return `expand: ${error.message.split("\n", 1)[0]}`;
+  }
+}
+function isSameFile(first, second) {
+  if (path2.resolve(first) === path2.resolve(second)) return true;
+  if (!existsSync(first) || !existsSync(second)) return false;
+  const a = statSync(first);
+  const b = statSync(second);
+  return a.dev === b.dev && a.ino === b.ino;
+}
+function problemWith(raw) {
+  if (raw.source.length === 0) return "expand requires at least one --source=<file>.";
+  if (raw.out.length === 0) return "expand requires --out=<file> for each --source.";
+  if (raw.source.length !== raw.out.length) {
+    return `expand takes one --out for each --source, matched by order: got ${raw.source.length} --source and ${raw.out.length} --out.`;
+  }
+  if ([...raw.source, ...raw.out, raw.extend ?? "."].includes("")) {
+    return "expand: a --source, --out or --extend value is empty.";
+  }
+  const outs = raw.out.map((file) => path2.resolve(file));
+  const inputs = [
+    ...raw.source.map((file) => ({ file, name: "a --source" })),
+    ...raw.extend === void 0 ? [] : [{ file: raw.extend, name: "the --extend module" }]
+  ];
+  for (const out of outs) {
+    const input = inputs.find(({ file }) => isSameFile(file, out));
+    if (input !== void 0) {
+      return `expand: --out ${out} is also ${input.name}; it would overwrite its own input.`;
+    }
+  }
+  if (new Set(outs).size !== outs.length)
+    return "expand: two files would be written to the same --out.";
+  return void 0;
+}
+function parseExpandArgs(args) {
+  const raw = readValues(args);
+  if (typeof raw === "string") return { kind: "usageError", message: raw };
+  const problem = problemWith(raw);
+  if (problem !== void 0) return { kind: "usageError", message: problem };
+  return {
+    kind: "job",
+    job: {
+      extend: raw.extend,
+      pairs: raw.source.map((source, index) => ({ source, out: raw.out[index] })),
+      watch: raw.watch
+    }
+  };
+}
+
+// src/directive/bare-imports.ts
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+var SCHEME = /^[a-z][a-z\d+.-]*:/i;
+function isTrivia(token) {
+  return token.type === "whitespace-token" || token.type === "comment";
+}
+function specifierOf(prelude) {
+  const [first, second] = prelude.filter((token) => !isTrivia(token));
+  if (first?.type === "string-token" || first?.type === "url-token") {
+    return first.structured.value;
+  }
+  const isUrlFunction = first?.type === "function-token" && first.structured.value.toLowerCase() === "url";
+  if (isUrlFunction && second?.type === "string-token") {
+    return second.structured.value;
+  }
+  return void 0;
+}
+function isBare(specifier, hasFile) {
+  const isUrlForm = withoutQueryOrFragment(specifier) === "" || specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../") || SCHEME.test(specifier);
+  return !isUrlForm && !hasFile(decoded(withoutQueryOrFragment(specifier)));
+}
+function withoutQueryOrFragment(specifier) {
+  const ends = [specifier.indexOf("?"), specifier.indexOf("#")].filter((at) => at !== -1);
+  return ends.length === 0 ? specifier : specifier.slice(0, Math.min(...ends));
+}
+function decoded(path4) {
+  try {
+    return decodeURIComponent(path4);
+  } catch {
+    return path4;
+  }
+}
+function endOfPrelude(tokens, from) {
+  const end = tokens.findIndex(
+    (token, index) => index >= from && (token.type === "semicolon-token" || token.type === "{-token")
+  );
+  return end === -1 ? tokens.length : end;
+}
+function readImport(tokens, index, hasFile) {
+  const end = endOfPrelude(tokens, index + 1);
+  const specifier = specifierOf(tokens.slice(index + 1, end));
+  if (specifier === void 0 || !isBare(specifier, hasFile)) return { diagnostic: void 0, end };
+  const lastIndex = tokens[end]?.type === "semicolon-token" ? end : end - 1;
+  const diagnostic = {
+    code: "bare-import",
+    offset: tokens[index].startIndex,
+    endOffset: tokens[lastIndex].endIndex,
+    text: specifier
+  };
+  return { diagnostic, end };
+}
+function findBareImports(css, hasFile) {
+  const tokens = tokenize(css);
+  const found = [];
+  let depth = 0;
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    let next = index + 1;
+    if (OPENERS.has(token.type)) depth++;
+    else if (CLOSERS.has(token.type)) depth = Math.max(0, depth - 1);
+    else if (depth === 0 && token.type === "at-keyword-token" && atKeywordName(token) === "import") {
+      const read = readImport(tokens, index, hasFile);
+      if (read.diagnostic) found.push(read.diagnostic);
+      next = read.end + 1;
+    }
+    index = next;
+  }
+  return found;
+}
+
+// src/expand-pass.ts
+function bareImportDiagnostics(css, source, out, outputs) {
+  const directory = path2.dirname(path2.resolve(out));
+  const positionAt = createPositionFinder(css);
+  const hasFile = (specifier) => {
+    const target = path2.resolve(directory, specifier);
+    return outputs.has(target) || statSync(target, { throwIfNoEntry: false })?.isFile() === true;
+  };
+  return findBareImports(css, hasFile).map((diagnostic) => {
+    const position = positionAt(diagnostic.offset);
+    return {
+      ...diagnostic,
+      severity: "error",
+      file: source,
+      line: position.line,
+      column: position.column + 1
+    };
+  });
+}
+function expandOne(pair, extend, outputs) {
+  const source = pair.source;
+  let raw;
+  try {
+    raw = readFileSync(source, "utf8");
+  } catch {
+    return { kind: "unreadable" };
+  }
+  const { bom, text } = splitByteOrderMark(raw);
+  try {
+    const result = expandText(text, { extend, onUnknown: "error", from: source });
+    const problems = [
+      ...result.diagnostics,
+      ...bareImportDiagnostics(text, source, pair.out, outputs)
+    ];
+    const report = foldedText(problems, source, extend);
+    return report === void 0 ? { kind: "expanded", css: bom + result.css } : { kind: "problems", report };
+  } catch (error) {
+    return { kind: "problems", report: `${source}: ${error.message}` };
+  }
+}
+function statusOf(unreadable, reports) {
+  if (unreadable.length > 0) return 2;
+  return reports.length > 0 ? 1 : 0;
+}
+function writeOutputs(outputs) {
+  const written = [];
+  for (const { css, pair } of outputs) {
+    try {
+      mkdirSync(path2.dirname(path2.resolve(pair.out)), { recursive: true });
+      writeFileSync(pair.out, css, "utf8");
+    } catch (error) {
+      const reason = error.message;
+      return {
+        written,
+        writeFailure: `Could not write ${pair.out}: ${reason}. No file after it was written.`
+      };
+    }
+    written.push(pair);
+  }
+  return { written, writeFailure: void 0 };
+}
+function expandPass(job, extend) {
+  const reports = [];
+  const unreadable = [];
+  const outputs = [];
+  const outPaths = new Set(job.pairs.map((pair) => path2.resolve(pair.out)));
+  for (const pair of job.pairs) {
+    const outcome = expandOne(pair, extend, outPaths);
+    if (outcome.kind === "unreadable") unreadable.push(pair.source);
+    else if (outcome.kind === "problems") reports.push(outcome.report);
+    else outputs.push({ css: outcome.css, pair });
+  }
+  const status = statusOf(unreadable, reports);
+  if (status !== 0) return { expanded: [], reports, status, unreadable, writeFailure: void 0 };
+  const { written, writeFailure } = writeOutputs(outputs);
+  return {
+    expanded: written,
+    reports,
+    status: writeFailure === void 0 ? 0 : 2,
+    unreadable,
+    writeFailure
+  };
+}
+var SETTLE_MS = 40;
+function watchFiles(files, onChange) {
+  const wanted = new Set(files.map((file) => path2.resolve(file)));
+  let timer;
+  const schedule = () => {
+    clearTimeout(timer);
+    timer = setTimeout(onChange, SETTLE_MS);
+  };
+  const watchedNames = new Set(wanted);
+  const directories = new Set([...wanted].map((file) => path2.dirname(file)));
+  for (const file of wanted) {
+    try {
+      const target = realpathSync(file);
+      watchedNames.add(target);
+      directories.add(path2.dirname(target));
+    } catch {
+    }
+  }
+  const watchers = [];
+  try {
+    for (const directory of directories) {
+      watchers.push(
+        watch(directory, (_event, name) => {
+          if (name === null || watchedNames.has(path2.join(directory, name))) schedule();
+        })
+      );
+    }
+  } catch (error) {
+    for (const watcher of watchers) watcher.close();
+    throw error;
+  }
+  return () => {
+    clearTimeout(timer);
+    for (const watcher of watchers) watcher.close();
+  };
+}
+
+// src/expand-command.ts
+async function loadExtend(file, cache) {
+  if (file === void 0) return {};
+  let loaded = {};
+  await applyExtendModule(file, cache, (value) => {
+    loaded = snapshotExtendMap(value);
+    validateExtendAtomsHostFree(loaded);
+  });
+  return loaded;
+}
+function print(result) {
+  for (const { source, out } of result.expanded) console.log(`Expanded ${source} to ${out}.`);
+  for (const report of result.reports) console.error(report);
+  for (const source of result.unreadable) {
+    console.error(`Could not read ${source}, so no file was written.`);
+  }
+  if (result.writeFailure !== void 0) console.error(result.writeFailure);
+}
+async function runOnce(job, extendFile, cache) {
+  let extend;
+  try {
+    extend = await loadExtend(extendFile, cache);
+  } catch (error) {
+    console.error(error.message);
+    return 2;
+  }
+  const result = expandPass(job, extend);
+  print(result);
+  return result.status;
+}
+async function watchAndRun(run, files) {
+  let isRunning = true;
+  let isPending = false;
+  const runAgain = async () => {
+    if (isRunning) {
+      isPending = true;
+      return;
+    }
+    isRunning = true;
+    do {
+      isPending = false;
+      await run();
+    } while (isPending);
+    isRunning = false;
+  };
+  try {
+    watchFiles(files, () => void runAgain());
+  } catch (error) {
+    console.error(`Could not watch: ${error.message}`);
+    return 2;
+  }
+  do {
+    isPending = false;
+    await run();
+  } while (isPending);
+  isRunning = false;
+  return new Promise(() => {
+  });
+}
+async function runExpand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(USAGE);
+    return 0;
+  }
+  const parsed = parseExpandArgs(args);
+  if (parsed.kind === "usageError") {
+    console.error(`${parsed.message}
+${USAGE}`);
+    return 2;
+  }
+  const { job } = parsed;
+  let extendFile;
+  try {
+    extendFile = job.extend === void 0 ? void 0 : resolveExtendSpecifier(job.extend);
+  } catch (error) {
+    console.error(error.message);
+    return 2;
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const run = () => runOnce(job, extendFile, cache);
+  if (!job.watch) return run();
+  const watched = [...job.pairs.map((pair) => pair.source), ...extendFile ? [extendFile] : []];
+  return watchAndRun(run, watched);
+}
+
+// src/bin.ts
+function isHelpRequest(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function parseSourceArgs(args) {
+  try {
+    const { values, positionals } = parseArgs({
+      args,
+      options: { source: { type: "string", multiple: true } },
+      strict: true,
+      allowPositionals: true
+    });
+    if (positionals.length > 0) {
+      return { kind: "unexpectedArgument", argument: positionals[0] };
+    }
+    return { kind: "source", source: values.source };
+  } catch {
+    return { kind: "usageError" };
+  }
+}
+function printFindings(result) {
+  for (const finding of result.findings) console.log(formatFinding(finding));
+}
+function printCleanSummary(result, source) {
+  if (result.status !== 0) return;
+  const plural = result.stylesheetsRead === 1 ? "stylesheet" : "stylesheets";
+  console.log(
+    `Checked ${result.stylesheetsRead} ${plural} under ${source.join(", ")}; found no @nave directive.`
+  );
+}
+function reportPathProblems(result, source, unreadablePaths, notStylesheetPaths) {
+  for (const badPath of unreadablePaths) {
+    console.error(`Could not read ${badPath}, so it was not checked.`);
+  }
+  for (const badPath of notStylesheetPaths) {
+    console.error(`${badPath} is not a stylesheet file, so it was not checked.`);
+  }
+  if (result.status === 2 && unreadablePaths.length === 0 && notStylesheetPaths.length === 0) {
+    console.error(`No stylesheet found under ${source.join(", ")}; nothing was checked.`);
+  }
+}
+async function runCheck2(args) {
+  if (isHelpRequest(args)) {
+    console.log(USAGE);
+    return 0;
+  }
+  const parsed = parseSourceArgs(args);
+  if (parsed.kind === "unexpectedArgument") {
+    console.error(`check does not take a positional argument: ${parsed.argument}
+${USAGE}`);
+    return 2;
+  }
+  const source = parsed.kind === "source" ? parsed.source : void 0;
+  if (!source || source.length === 0 || source.includes("")) {
+    console.error(`check requires at least one --source=<path>.
+${USAGE}`);
+    return 2;
+  }
+  const { result, unreadablePaths, notStylesheetPaths } = await runCheck(source);
+  printFindings(result);
+  printCleanSummary(result, source);
+  reportPathProblems(result, source, unreadablePaths, notStylesheetPaths);
+  return result.status;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error(USAGE);
+    return 2;
+  }
+  if (isHelpRequest([args[0]])) {
+    console.log(USAGE);
+    return 0;
+  }
+  const [subcommand, ...rest] = args;
+  if (subcommand === "expand") return runExpand(rest);
+  if (subcommand !== "check") {
+    console.error(`Unknown subcommand "${subcommand}".
+${USAGE}`);
+    return 2;
+  }
+  return runCheck2(rest);
+}
+process.exitCode = await main();

package/dist/check.d.ts

@@ -0,0 +1,31 @@
+interface Finding {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+    readonly selector?: string;
+}
+
+interface CheckOptions {
+    readonly source: readonly string[];
+}
+interface CheckResult {
+    readonly status: 0 | 1 | 2;
+    readonly findings: readonly Finding[];
+    readonly stylesheetsRead: number;
+}
+
+/**
+ * `check({ source })`, the core logic behind both the `navecss-core
+ * check` bin and the `@navecss/core/check` subpath. Exit contract mirrors
+ * `navecss-tokens`: `0` read at least one stylesheet and found none, `1`
+ * found at least one, `2` a usage error, an unreadable path, or no
+ * stylesheet found at all.
+ */
+
+/**
+`check({ source })`: reads every stylesheet under `source`, reporting every surviving `@nave`.
+ */
+declare function check(options: CheckOptions): Promise<CheckResult>;
+
+export { type CheckOptions, type CheckResult, type Finding, check };

package/dist/check.js

@@ -0,0 +1,11 @@
+import { runCheck } from './chunk-XQQCDUV6.js';
+import './chunk-UANF3FGO.js';
+import './chunk-NFS2REPQ.js';
+
+// src/directive/check.ts
+async function check(options) {
+  const run = await runCheck(options.source);
+  return run.result;
+}
+
+export { check };

package/dist/chunk-IZQLFUQU.js

@@ -0,0 +1,30 @@
+import { formatDiagnostic, foldLocated } from './chunk-S7DZUVV3.js';
+
+// src/byte-order-mark.ts
+var BYTE_ORDER_MARK = "\uFEFF";
+function splitByteOrderMark(raw) {
+  return raw.startsWith(BYTE_ORDER_MARK) ? { bom: BYTE_ORDER_MARK, text: raw.slice(BYTE_ORDER_MARK.length) } : { bom: "", text: raw };
+}
+
+// src/directive/report-text.ts
+function inSourceOrder(diagnostics) {
+  return diagnostics.toSorted((a, b) => a.offset - b.offset);
+}
+function warningTexts(diagnostics, file, extend) {
+  return inSourceOrder(diagnostics).map(
+    (diagnostic) => `${file}:${diagnostic.line}:${diagnostic.column}: ${formatDiagnostic(diagnostic, { extend })}`
+  );
+}
+function foldedText(diagnostics, file, extend) {
+  const ordered = inSourceOrder(diagnostics);
+  const first = ordered[0];
+  if (first === void 0) return void 0;
+  const located = ordered.map((diagnostic) => ({
+    text: formatDiagnostic(diagnostic, { extend }),
+    line: diagnostic.line,
+    column: diagnostic.column
+  }));
+  return `${file}:${first.line}:${first.column}: ${foldLocated(located)}`;
+}
+
+export { foldedText, splitByteOrderMark, warningTexts };

package/dist/{chunk-BVON7XKC.js → chunk-LIUB4EES.js}

@@ -169,6 +169,10 @@ var atoms = {
   /**
    * focusRing — keyboard focus indicator.
    * :focus-visible — keyboard users see it, mouse users do not.
+   *
+   * Longhands with fallbacks, not an `outline` shorthand, which computes to `none` as a whole when
+   * a `var()` in it has no usable value: no token layer, a missing property, or a wrong-typed value
+   * in an unregistered property. The fallbacks are 2px and `currentColor`, never a literal colour.
    */
   focusRing: {
     declarations: {
@@ -176,7 +180,9 @@ var atoms = {
     },
     pseudos: {
       ":focus-visible": {
-        outline: "var(--nave-border-width-focus) solid var(--nave-color-border-focus)",
+        "outline-style": "solid",
+        "outline-width": "var(--nave-border-width-focus, 2px)",
+        "outline-color": "var(--nave-color-border-focus, currentColor)",
         "outline-offset": "2px"
       }
     }