@navecss/core 0.4.0 → 0.5.0

package/dist/chunk-UVHGEVMV.js

@@ -0,0 +1,204 @@
+// src/directive/expand-text-diagnostics.ts
+function lineStartOffsets(text) {
+  const starts = [0];
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\r") {
+      i++;
+      if (text[i] === "\n") i++;
+      starts.push(i);
+      continue;
+    }
+    if (c === "\n" || c === "\f") {
+      i++;
+      starts.push(i);
+      continue;
+    }
+    i++;
+  }
+  return starts;
+}
+function lastAtOrBefore(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function createPositionFinder(text) {
+  const starts = lineStartOffsets(text);
+  return (offset) => {
+    const line = lastAtOrBefore(starts, offset);
+    return { line: line + 1, column: offset - starts[line] };
+  };
+}
+function reportDiagnostics(diagnostics, css, options) {
+  const onUnknown = options.onUnknown ?? "error";
+  if (onUnknown === "ignore") return [];
+  const severity = onUnknown === "warn" ? "warning" : "error";
+  const positionAt = createPositionFinder(css);
+  return diagnostics.map((diagnostic) => {
+    const position = positionAt(diagnostic.offset);
+    return {
+      ...diagnostic,
+      severity,
+      ...options.from !== void 0 && { file: options.from },
+      line: position.line,
+      column: position.column + 1
+    };
+  });
+}
+function positionWarnings(warnings, css, file) {
+  const positionAt = createPositionFinder(css);
+  return warnings.toSorted((a, b) => a.offset - b.offset).map(({ offset, text }) => {
+    const position = positionAt(offset);
+    return {
+      text,
+      offset,
+      line: position.line,
+      column: position.column + 1,
+      ...file !== void 0 && { file }
+    };
+  });
+}
+
+// src/directive/bracket-match.ts
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function isMirrorCloser(openerType, closerType) {
+  if (closerType === ")-token") return openerType === "(-token" || openerType === "function-token";
+  if (closerType === "]-token") return openerType === "[-token";
+  return openerType === "{-token";
+}
+function matchBrackets(tokens) {
+  const closerFor = new Int32Array(tokens.length).fill(-1);
+  const opens = [];
+  for (const [i, token] of tokens.entries()) {
+    const { type } = token;
+    if (OPENERS.has(type)) {
+      opens.push(i);
+      continue;
+    }
+    if (!CLOSERS.has(type)) continue;
+    const openIndex = opens.at(-1);
+    if (openIndex === void 0 || !isMirrorCloser(tokens[openIndex].type, type)) continue;
+    opens.pop();
+    closerFor[openIndex] = i;
+  }
+  return closerFor;
+}
+function matchedCloseWithin(closerFor, openIndex, limit) {
+  const closeIndex = closerFor[openIndex];
+  return closeIndex !== -1 && closeIndex < limit ? closeIndex : void 0;
+}
+
+// src/directive/block-reader.ts
+function scanItem(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      if (type === "{-token") {
+        return {
+          end: closeIndex === void 0 ? limit : closeIndex + 1,
+          consumedSemicolon: false,
+          trailingBlock: { openIndex: i, closeIndex }
+        };
+      }
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (CLOSERS.has(type)) {
+      if (i === start) return { end: i + 1, consumedSemicolon: false };
+      i++;
+      continue;
+    }
+    if (type === "semicolon-token") return { end: i + 1, consumedSemicolon: true };
+    i++;
+  }
+  return { end: i, consumedSemicolon: false };
+}
+function scanCustomPropertyValue(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (type === "semicolon-token") return i + 1;
+    i++;
+  }
+  return i;
+}
+function isColonSoonAfter(tokens, i, limit) {
+  let j = i;
+  while (j < limit && (tokens[j].type === "whitespace-token" || tokens[j].type === "comment")) j++;
+  return tokens[j]?.type === "colon-token";
+}
+function isCustomPropertyName(token) {
+  return token.type === "ident-token" && (token.structured?.value).startsWith("--");
+}
+function atKeywordName(token) {
+  return (token.structured?.value).toLowerCase();
+}
+function toDeclarationItem(start, end) {
+  return { kind: "declaration", start, end };
+}
+function preludeEndOffset(tokens, start, scan, preludeStart) {
+  if (scan.trailingBlock) return tokens[scan.trailingBlock.openIndex].startIndex;
+  const lastContentIndex = scan.consumedSemicolon ? scan.end - 2 : scan.end - 1;
+  return lastContentIndex >= start ? tokens[lastContentIndex].endIndex : preludeStart;
+}
+function toAtRuleItem(tokens, start, scan) {
+  const nameToken = tokens[start];
+  const preludeStart = tokens[start + 1]?.startIndex ?? nameToken.endIndex;
+  return {
+    kind: "at-rule",
+    start,
+    end: scan.end,
+    atKeyword: atKeywordName(nameToken),
+    preludeOffset: preludeStart,
+    preludeEndOffset: preludeEndOffset(tokens, start + 1, scan, preludeStart),
+    ...scan.trailingBlock && {
+      blockStart: scan.trailingBlock.openIndex + 1,
+      blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+    }
+  };
+}
+function toRuleOrInvalidItem(start, scan) {
+  if (!scan.trailingBlock) return { kind: "invalid", start, end: scan.end };
+  return {
+    kind: "rule",
+    start,
+    end: scan.end,
+    blockStart: scan.trailingBlock.openIndex + 1,
+    blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+  };
+}
+function readItem(tokens, start, limit, closerFor) {
+  const first = tokens[start];
+  if (first.type === "at-keyword-token") {
+    return toAtRuleItem(tokens, start, scanItem(tokens, start + 1, limit, closerFor));
+  }
+  if (first.type === "ident-token" && isColonSoonAfter(tokens, start + 1, limit)) {
+    if (isCustomPropertyName(first)) {
+      return toDeclarationItem(start, scanCustomPropertyValue(tokens, start + 1, limit, closerFor));
+    }
+    const scan = scanItem(tokens, start + 1, limit, closerFor);
+    if (!scan.trailingBlock) return toDeclarationItem(start, scan.end);
+    return toRuleOrInvalidItem(start, scan);
+  }
+  return toRuleOrInvalidItem(start, scanItem(tokens, start, limit, closerFor));
+}
+function isNaveAtKeyword(token) {
+  return token.type === "at-keyword-token" && atKeywordName(token) === "nave";
+}
+
+export { OPENERS, atKeywordName, createPositionFinder, isNaveAtKeyword, matchBrackets, positionWarnings, readItem, reportDiagnostics };

package/dist/{chunk-UANF3FGO.js → chunk-ZNTNLGEC.js}

@@ -1,4 +1,5 @@
-import { createPositionFinder, tokenize, matchBrackets, readItem, isNaveAtKeyword } from './chunk-NFS2REPQ.js';
+import { createPositionFinder, matchBrackets, readItem, isNaveAtKeyword } from './chunk-UVHGEVMV.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
 
 // src/directive/find-survivors.ts
 var NATURAL_STOP_CHARS = /* @__PURE__ */ new Set(["\n", ";", "}"]);

package/dist/collect.d.ts

@@ -1,5 +1,5 @@
-export { R as ResolvedUsedOptions, U as UsedAtomOptions, a as assertOptions, k as keptAtoms, r as resolveUsedOptions } from './vite-options-D1-hGA9L.js';
-import './atom-names-2OreuBx9.js';
+export { R as ResolvedUsedOptions, U as UsedAtomOptions, a as assertOptions, k as keptAtoms, r as resolveUsedOptions } from './vite-options-sOCeGn9B.js';
+import './atom-names-B8Ud-7zD.js';
 
 /**
  * The few shapes of the ESTree `this.parse` returns that the collector reads, declared here
@@ -169,6 +169,37 @@ declare const CX_SOURCE = "@navecss/core/cx";
  */
 declare function readModule(code: string, program: AstNode, options: ReadOptions): ModuleReading;
 
+interface LayerReading {
+    /**
+     * Whether the stylesheet holds an `@layer atomic { ... }` block.
+     */
+    readonly hasLayer: boolean;
+    /**
+     * The built-in atoms whose class a rule in the layer selects.
+     */
+    readonly atoms: Set<string>;
+}
+/**
+ * `css` with every rule in an `@layer atomic` block that needs an atom outside `emitted` removed.
+ */
+declare function pruneAtomicLayer(css: string, emitted: ReadonlySet<string>): string;
+/**
+ * What the `@layer atomic` blocks of `css` hold.
+ */
+declare function inspectAtomicLayer(css: string): LayerReading;
+/**
+ * The atoms outside `emitted` that a rule left in the `@layer atomic` blocks of `css` still needs
+ * an element of: what a pruning to `emitted` would still remove, sorted.
+ */
+declare function unprunedAtoms(css: string, emitted: ReadonlySet<string>): string[];
+
+/**
+ * `atoms` with the atoms added that restore what an atom in it removes: `srOnlyFocusable` shows
+ * again on focus what `srOnly` hides, so a set that holds `srOnly` holds it too. This adds to the
+ * emitted set only, not to `keep` or to what `cx.dynamic()` accepts.
+ */
+declare function withRestorers(atoms: Set<string>): Set<string>;
+
 /**
  * What an importer takes from a module that gives out Nave's `cx`: which of its `cx` exports it
  * imports, re-exports or reads off a namespace. The test is by name, not by file: an importer that
@@ -269,11 +300,18 @@ interface LocatedProblem extends Problem {
     readonly callers?: readonly string[] | undefined;
 }
 declare const REPORT_CAUSE = "the build cannot tell which atoms these apply, and it ships only the atoms it can read.";
+/**
+ * The remedy lines only a host can write, given the application's problems: they print after the
+ * lines of the application's kinds and before any package's line.
+ */
+type HostRemedies = (application: readonly LocatedProblem[]) => readonly string[];
 /**
  * The build report for every problem of an environment. `configured` is the `cxModules` list the
  * remedies that print one extend, and `home` is how the host spells where the options are written,
- * the call of its plugin or its wrapper: the one place the report names its host.
+ * the call of its plugin or its wrapper: the one place the report names its host. `hostRemedies`
+ * adds the lines only the host can write.
  */
-declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string): string;
+declare function buildReport(problems: readonly LocatedProblem[], configured: readonly string[], home: string, hostRemedies?: HostRemedies): string;
 
-export { type AstNode, CX_SOURCE, type LocatedProblem, type ModuleReading, type Problem, type ProblemKind, REPORT_CAUSE, type ReadOptions, buildReport, readModule };
+export { CX_SOURCE, REPORT_CAUSE, buildReport, inspectAtomicLayer, pruneAtomicLayer, readModule, unprunedAtoms, withRestorers };
+export type { AstNode, HostRemedies, LayerReading, LocatedProblem, ModuleReading, Problem, ProblemKind, ReadOptions };

package/dist/collect.js

@@ -1,4 +1,5 @@
-export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, keptAtoms, readModule, resolveUsedOptions } from './chunk-E5F6YF7A.js';
+export { CX_SOURCE, REPORT_CAUSE, assertOptions, buildReport, inspectAtomicLayer, keptAtoms, pruneAtomicLayer, readModule, resolveUsedOptions, unprunedAtoms, withRestorers } from './chunk-BCUK4M4P.js';
 import './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
+import './chunk-2K5EBBF2.js';
 import './chunk-GZL2VW7C.js';

package/dist/css.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cx.d.ts

@@ -1,4 +1,4 @@
-import { A as AtomName } from './atom-names-2OreuBx9.js';
+import { A as AtomName } from './atom-names-B8Ud-7zD.js';
 
 /**
  * cx — typed atomic class composer for Nave.

package/dist/lightningcss.d.ts

@@ -1,5 +1,5 @@
 import { AtomDefinition } from './atoms.js';
-import './atom-names-2OreuBx9.js';
+import './atom-names-B8Ud-7zD.js';
 
 interface NaveLightningOptions {
     /**
@@ -48,4 +48,5 @@ interface NaveLightningAdapter {
  */
 declare function navePlugin(options?: NaveLightningOptions): NaveLightningAdapter;
 
-export { type NaveLightningAdapter, type NaveLightningOptions, navePlugin as default, navePlugin };
+export { navePlugin as default, navePlugin };
+export type { NaveLightningAdapter, NaveLightningOptions };

package/dist/lightningcss.js

@@ -1,9 +1,11 @@
-import { splitByteOrderMark, warningTexts, foldedText } from './chunk-2A7IUZBH.js';
-import { validateExtendAtomsHostFree } from './chunk-LQSGQ2OA.js';
-import { snapshotExtendMap, expandText } from './chunk-LADFXRWQ.js';
-import './chunk-NFS2REPQ.js';
+import { splitByteOrderMark } from './chunk-2TNTYI4L.js';
+import { orderWarningTexts, warningTexts, foldedText } from './chunk-KKUYU75D.js';
+import { validateExtendAtomsHostFree } from './chunk-63H2FLGU.js';
+import { snapshotExtendMap, expandText } from './chunk-MWHZ26S4.js';
+import './chunk-UVHGEVMV.js';
 import './chunk-SYNQJNVB.js';
 import './chunk-CUL5PLPI.js';
+import './chunk-2K5EBBF2.js';
 import './chunk-GZL2VW7C.js';
 import { readFileSync } from 'fs';
 
@@ -21,6 +23,7 @@ function navePlugin(options = {}) {
   validateExtendAtomsHostFree(extend);
   const expandToText = (text, file) => {
     const result = expandText(text, { extend, onUnknown, from: file });
+    for (const line of orderWarningTexts(result.warnings, file)) console.warn(line);
     report(result.diagnostics, file, extend, onUnknown);
     return result;
   };

package/dist/postcss.d.ts

@@ -1,6 +1,22 @@
-import { Plugin } from 'postcss';
+import { Warning, Plugin } from 'postcss';
 import { AtomDefinition } from './atoms.js';
-import './atom-names-2OreuBx9.js';
+import './atom-names-B8Ud-7zD.js';
+
+/**
+ * The one place the PostCSS host reports a warning: `node.warn()`, except under Next.js's
+ * Turbopack, which drops every PostCSS warning. There (detected by `process.env.TURBOPACK` being
+ * set) the text is printed with `console.warn` behind the same `file:line:column: ` frame the
+ * Lightning CSS adapter prints, and `node.warn()` is not called as well. A tool that runs the
+ * plugin itself and reports its warnings turns the printing off (`printWarnings: false`): every
+ * warning is then raised, whatever `TURBOPACK` says.
+ */
+
+/**
+ * Whether `warning` is an order warning (one `order-warnings.ts` or `shape-warnings.ts` makes)
+ * and not an `onUnknown` problem. No `onUnknown` governs it and it never fails a build, so a tool
+ * running the plugin with `printWarnings: false` reports it as a warning, never as a problem.
+ */
+declare function isOrderWarning(warning: Warning): boolean;
 
 /**
  * Nave PostCSS plugin — resolves @nave directives.
@@ -18,6 +34,7 @@ import './atom-names-2OreuBx9.js';
  *   navePlugin()                         // Nave atoms only, fails build on unknown atom
  *   navePlugin({ extend: myAtoms })      // Nave + consumer atoms
  *   navePlugin({ onUnknown: 'warn' })    // Log and skip instead of failing the build
+ *   navePlugin({ onUnknown: 'warn', printWarnings: false }) // Raise warnings only, never print
  *
  * `extend` is trusted, consumer-authored code (your build config, or the module a path names),
  * which can already run arbitrary JavaScript at build time: it is not sanitised input. Every
@@ -77,10 +94,19 @@ interface NavePluginOptions {
      * 'ignore' — silently skip
      */
     onUnknown?: 'warn' | 'error' | 'ignore';
+    /**
+     * Whether a warning may be printed: a problem under 'warn', or an order warning. Under
+     * Turbopack (`TURBOPACK` set), which shows no PostCSS warning, the plugin prints each one with
+     * `console.warn` instead of raising it (default `true`). `false` raises it as a PostCSS warning
+     * only, whatever `TURBOPACK` says: for a tool that runs the plugin itself and reports the
+     * warnings it raises, telling the two apart with `isOrderWarning()`.
+     */
+    printWarnings?: boolean;
 }
 declare const navePlugin: {
     (options?: NavePluginOptions): Plugin;
     postcss: boolean;
 };
 
-export { AtomDefinition, type NavePluginOptions, navePlugin as default, navePlugin };
+export { AtomDefinition, navePlugin as default, isOrderWarning, navePlugin };
+export type { NavePluginOptions };