@navecss/core 0.1.1 → 0.3.0

package/dist/postcss.js

@@ -1,138 +1,39 @@
-import { atoms } from './chunk-BVON7XKC.js';
+import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
+import { snapshotExtendMap, walkExtendAtoms, foldLocated, anchorSelectorList, plan, formatDiagnostic, WORKAROUND_GROUP_AT_RULE_NAMES } from './chunk-S7DZUVV3.js';
+import { tokenize } from './chunk-NFS2REPQ.js';
+import './chunk-LIUB4EES.js';
 import postcss from 'postcss';
 
-// src/selector-utils.ts
-function nextQuote(quote, char) {
-  if (quote) return char === quote ? void 0 : quote;
-  return char === '"' || char === "'" ? char : quote;
-}
-function depthDelta(quote, char) {
-  if (quote) return 0;
-  if (char === "(" || char === "[") return 1;
-  if (char === ")" || char === "]") return -1;
-  return 0;
-}
-function consumeSplitChar(state, char) {
-  const { branches, depth, quote, isEscaped, current } = state;
-  if (isEscaped) {
-    return { branches, depth, quote, isEscaped: false, current: current + char };
-  }
-  if (char === "\\") {
-    return { branches, depth, quote, isEscaped: true, current: current + char };
-  }
-  const nextDepth = depth + depthDelta(quote, char);
-  if (!quote && char === "," && nextDepth === 0) {
-    return {
-      branches: [...branches, current],
-      depth: nextDepth,
-      quote,
-      isEscaped: false,
-      current: ""
-    };
-  }
-  return {
-    branches,
-    depth: nextDepth,
-    quote: nextQuote(quote, char),
-    isEscaped: false,
-    current: current + char
-  };
-}
-function splitTopLevel(selectorList) {
-  let state = {
-    branches: [],
-    depth: 0,
-    quote: void 0,
-    isEscaped: false,
-    current: ""
-  };
-  for (const char of selectorList) state = consumeSplitChar(state, char);
-  return [...state.branches, state.current];
-}
-function hasUnquotedAmpersand(branch) {
-  let quote;
-  let isEscaped = false;
-  for (const char of branch) {
-    if (isEscaped) {
-      isEscaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      isEscaped = true;
-      continue;
-    }
-    if (!quote && char === "&") return true;
-    quote = nextQuote(quote, char);
-  }
-  return false;
-}
-function anchorSelectorList(selectorList) {
-  return splitTopLevel(selectorList).map((branch) => {
-    const trimmed = branch.trim();
-    if (trimmed === "") {
-      throw new Error(
-        `anchorSelectorList: empty selector branch in pseudo key "${selectorList}". Remove the stray or trailing comma: an empty branch would otherwise compile to a bare "&", matching the atom unconditionally.`
-      );
-    }
-    return hasUnquotedAmpersand(trimmed) ? trimmed : `&${trimmed}`;
-  }).join(", ");
-}
-
 // src/postcss-nested-builders.ts
-var DIRECTIVE = "nave";
-function buildNestedRule(selector, decls) {
-  const rule = postcss.rule({ selector });
-  for (const [prop, value] of Object.entries(decls)) {
-    rule.append(postcss.decl({ prop, value }));
-  }
-  return rule;
-}
-function buildPseudoRules(pseudos) {
-  return Object.entries(pseudos).map(
-    ([pseudo, decls]) => buildNestedRule(anchorSelectorList(pseudo), decls)
-  );
-}
-function buildInnerRules(block) {
-  const rules = [];
-  if (block.declarations) rules.push(buildNestedRule("&", block.declarations));
-  if (block.pseudos) rules.push(...buildPseudoRules(block.pseudos));
-  return rules;
-}
-function buildAtBlock(atName, condition, block) {
-  const inner = buildInnerRules(block);
-  if (inner.length === 0) return void 0;
-  const node = postcss.atRule({ name: atName, params: condition });
-  for (const rule of inner) node.append(rule);
-  return node;
-}
-function buildNested(atom) {
-  const nodes = [];
-  if (atom.pseudos) nodes.push(...buildPseudoRules(atom.pseudos));
-  for (const atName of ["media", "container"]) {
-    const blocks = atom[atName] ?? {};
-    for (const [condition, block] of Object.entries(blocks)) {
-      const node = buildAtBlock(atName, condition, block);
-      if (node) nodes.push(node);
-    }
-  }
-  return nodes;
-}
 function isNestedNode(node) {
-  return node.type === "rule" || node.type === "atrule" && node.name !== DIRECTIVE;
+  return node.type === "rule" || node.type === "atrule" && node.name.toLowerCase() !== "nave";
 }
 function isFollowingNestedNode(rule, atRule) {
   return rule.nodes.slice(0, rule.index(atRule)).some((node) => isNestedNode(node));
 }
 
 // src/postcss-node-utils.ts
-function isInsideKeyframes(rule) {
-  let node = rule.parent;
+function isInsideKeyframes(container) {
+  let node = container;
   while (node) {
     if (node.type === "atrule" && /keyframes$/i.test(node.name)) return true;
     node = node.parent;
   }
   return false;
 }
+function hasWorkaroundSentence(refusedParent) {
+  if (refusedParent.type !== "atrule") return false;
+  if (!WORKAROUND_GROUP_AT_RULE_NAMES.has(refusedParent.name.toLowerCase())) {
+    return false;
+  }
+  if (isInsideKeyframes(refusedParent)) return false;
+  let current = refusedParent.parent;
+  while (current) {
+    if (current.type === "rule") return true;
+    current = current.parent;
+  }
+  return false;
+}
 function stampSource(node, source) {
   if (!source) return;
   node.source = source;
@@ -141,88 +42,265 @@ function stampSource(node, source) {
   });
 }
 
-// src/postcss.ts
-function reportUnknown(msg, ctx) {
-  const { atRule, onUnknown, result } = ctx;
-  if (onUnknown === "warn") {
-    atRule.warn(result, msg);
-    return;
-  }
-  if (onUnknown === "ignore") return;
-  throw atRule.error(msg);
+// src/postcss-at-rule.ts
+function currentParams(atRule) {
+  const raw = atRule.raws.params;
+  if (raw?.value === atRule.params) return raw.raw;
+  return atRule.params;
+}
+function matchNaveAtRule(atRule) {
+  const afterName = atRule.raws.afterName ?? " ";
+  const paramsRaw = currentParams(atRule);
+  const nameBoundary = 1 + atRule.name.length;
+  const full = `@${atRule.name}${afterName}${paramsRaw}`;
+  const token = tokenize(full)[0];
+  const commonPrelude = { prelude: paramsRaw, preludeStartIndex: nameBoundary + afterName.length };
+  if (token?.type !== "at-keyword-token") return { isNave: false, ...commonPrelude };
+  const isNave = (token.structured?.value).toLowerCase() === "nave";
+  if (token.endIndex === nameBoundary) return { isNave, ...commonPrelude };
+  return { isNave, prelude: full.slice(token.endIndex), preludeStartIndex: token.endIndex };
 }
-function checkUnknownAtoms(names, validAtomNames, ctx) {
-  if (names.length === 0) {
-    reportUnknown("@nave: directive names no atom", ctx);
+function atRuleErrorIndex(preludeStartIndex, diagnostic) {
+  if (diagnostic.code !== "unknown-atom" && diagnostic.code !== "bad-token") return void 0;
+  return preludeStartIndex + diagnostic.offset;
+}
+function reportDiagnostic(diagnostic, ctx, preludeStartIndex) {
+  const refusedParent = ctx.atRule.parent;
+  const isNestedGroup = diagnostic.code === "bad-parent" && refusedParent !== void 0 && hasWorkaroundSentence(refusedParent);
+  const text = formatDiagnostic(
+    isNestedGroup ? { ...diagnostic, detail: "nested-group" } : diagnostic,
+    {
+      extend: ctx.extend
+    }
+  );
+  const index = atRuleErrorIndex(preludeStartIndex, diagnostic);
+  if (ctx.onUnknown === "warn") {
+    ctx.atRule.warn(ctx.result, text, index === void 0 ? {} : { index });
     return;
   }
-  for (const name of names) {
-    if (validAtomNames.has(name)) continue;
-    reportUnknown(
-      `@nave: unknown atom "${name}". Available: ${[...validAtomNames].join(", ")}`,
-      ctx
-    );
-  }
+  if (ctx.onUnknown === "ignore") return;
+  ctx.fold.push({ atRule: ctx.atRule, text, index });
 }
-function insertDeclarations(atRule, declNodes, isFollowingNested) {
-  if (declNodes.length === 0) return;
-  if (!isFollowingNested) {
-    for (const decl of declNodes) atRule.before(decl);
+function declNode(atRule, decl) {
+  const node = postcss.decl({ prop: decl.prop, value: decl.value });
+  if (atRule.source) node.source = atRule.source;
+  return node;
+}
+function insertDeclarations(atRule, declarations, isWrapped) {
+  if (declarations.length === 0) return;
+  if (!isWrapped) {
+    for (const decl of declarations) atRule.before(declNode(atRule, decl));
     return;
   }
   const wrapper = postcss.rule({ selector: "&" });
   if (atRule.source) wrapper.source = atRule.source;
-  for (const decl of declNodes) wrapper.append(decl);
+  for (const decl of declarations) wrapper.append(declNode(atRule, decl));
   atRule.before(wrapper);
 }
-var navePlugin = (options = {}) => {
-  const { onUnknown = "error", extend = {} } = options;
-  const allAtoms = { ...atoms, ...extend };
-  const validAtomNames = new Set(
-    Object.entries(allAtoms).filter(([, definition]) => definition).map(([name]) => name)
+function buildRule(selector, declarations) {
+  const rule = postcss.rule({ selector });
+  for (const decl of declarations) rule.append(postcss.decl({ prop: decl.prop, value: decl.value }));
+  return rule;
+}
+function buildAppendedNode(block) {
+  if (block.kind === "pseudo") return buildRule(block.selector, block.declarations);
+  const node = postcss.atRule({ name: block.kind, params: block.condition });
+  if (block.declarations.length > 0) node.append(buildRule("&", block.declarations));
+  for (const pseudo of block.pseudos) node.append(buildRule(pseudo.selector, pseudo.declarations));
+  return node;
+}
+function throwMalformedAtom(atRule, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  throw atRule.error(message);
+}
+function planAtRule(atRule, extend, prelude) {
+  const parent = atRule.parent;
+  const isStyleRuleParent = parent?.type === "rule";
+  const isFollowingNestedNodeHere = isStyleRuleParent ? isFollowingNestedNode(parent, atRule) : false;
+  try {
+    return {
+      isStyleRuleParent,
+      parent,
+      result: plan(
+        prelude,
+        {
+          isStyleRuleParent,
+          isInsideKeyframes: parent !== void 0 && isInsideKeyframes(parent),
+          isFollowingNestedNode: isFollowingNestedNodeHere
+        },
+        { extend }
+      )
+    };
+  } catch (error) {
+    return throwMalformedAtom(atRule, error);
+  }
+}
+function hasBlock(atRule) {
+  return atRule.nodes !== void 0;
+}
+function handleAtRule(atRule, ctx) {
+  const match = matchNaveAtRule(atRule);
+  if (!match.isNave) return;
+  const fullCtx = { ...ctx, atRule };
+  const {
+    isStyleRuleParent,
+    parent,
+    result: planResult
+  } = planAtRule(atRule, ctx.extend, match.prelude);
+  for (const diagnostic of planResult.diagnostics) {
+    reportDiagnostic(diagnostic, fullCtx, match.preludeStartIndex);
+  }
+  if (hasBlock(atRule)) {
+    reportDiagnostic(
+      { code: "has-block", offset: 0, endOffset: atRule.toString().length },
+      fullCtx,
+      match.preludeStartIndex
+    );
+  }
+  insertDeclarations(atRule, planResult.declarations, planResult.wrapInAmpersand);
+  atRule.remove();
+  if (isStyleRuleParent && parent) {
+    for (const block of planResult.blocks) {
+      const node = buildAppendedNode(block);
+      stampSource(node, atRule.source);
+      parent.append(node);
+    }
+  }
+}
+
+// src/postcss-fold.ts
+function positionOf(entry, fallbackLine) {
+  if (!entry.atRule.source) return { column: 0, line: fallbackLine };
+  return entry.atRule.positionBy(entry.index === void 0 ? {} : { index: entry.index });
+}
+function sortFoldBySourceOrder(entries) {
+  return entries.map((entry, originalIndex) => ({ entry, originalIndex })).toSorted((a, b) => {
+    const pa = positionOf(a.entry, a.originalIndex);
+    const pb = positionOf(b.entry, b.originalIndex);
+    return pa.line - pb.line || pa.column - pb.column;
+  }).map(({ entry }) => entry);
+}
+function foldMessage(entries) {
+  return foldLocated(
+    entries.map((entry, i) => {
+      const position = positionOf(entry, i);
+      return { text: entry.text, line: position.line, column: position.column };
+    })
   );
+}
+function unescapeHtml(text) {
+  return text.replaceAll(/\\3c (?=\/?style\b|!--)/gi, "<");
+}
+function compact(text) {
+  return text.replaceAll(/\s+/g, "");
+}
+function declarationRefusal(prop, value) {
+  let root;
+  try {
+    root = postcss.parse(`a{${prop}:${value}}`);
+  } catch {
+    return "break-out";
+  }
+  if (root.nodes.length !== 1) return "break-out";
+  const rule = root.nodes[0];
+  if (rule.type !== "rule" || rule.nodes.length !== 1) return "break-out";
+  const decl = rule.nodes[0];
+  if (decl.type !== "decl" || decl.prop !== prop) return "break-out";
+  const given = `${prop}:${value}`;
+  const written = decl.toString();
+  if (written === given.trimEnd()) return void 0;
+  return compact(unescapeHtml(written)) === compact(given) ? "rewritten" : "break-out";
+}
+function propRefusal(prop) {
+  return declarationRefusal(prop, "0");
+}
+function selectorRefusal(key) {
+  let selector;
+  try {
+    selector = anchorSelectorList(key);
+  } catch {
+    return "break-out";
+  }
+  let root;
+  try {
+    root = postcss.parse(`${selector}{}`);
+  } catch {
+    return "break-out";
+  }
+  if (root.nodes.length !== 1) return "break-out";
+  const rule = root.nodes[0];
+  const isOneEmptyRule = rule.type === "rule" && rule.selector === selector;
+  return isOneEmptyRule && rule.nodes.length === 0 ? void 0 : "break-out";
+}
+function conditionRefusal(atName, condition) {
+  let root;
+  try {
+    root = postcss.parse(`@${atName} ${condition}{}`);
+  } catch {
+    return "break-out";
+  }
+  if (root.nodes.length !== 1) return "break-out";
+  const node = root.nodes[0];
+  if (node.type !== "atrule" || node.name !== atName || (node.nodes?.length ?? 0) !== 0) {
+    return "break-out";
+  }
+  if (node.params === condition.trim()) return void 0;
+  return compact(node.params) === compact(condition) ? "rewritten" : "break-out";
+}
+function validateExtendAtoms(extend) {
+  walkExtendAtoms(extend, { declarationRefusal, propRefusal, selectorRefusal, conditionRefusal });
+}
+
+// src/postcss.ts
+var navePlugin = (options = {}) => {
+  const { onUnknown = "error", extend: extendOption } = options;
+  const extendFile = typeof extendOption === "string" ? resolveExtendSpecifier(extendOption) : void 0;
+  const staticExtend = typeof extendOption === "object" ? snapshotExtendMap(extendOption) : {};
+  validateExtendAtoms(staticExtend);
+  const loadCache = /* @__PURE__ */ new Map();
   return {
     postcssPlugin: "postcss-nave",
-    AtRule(atRule, { result }) {
-      if (atRule.name !== DIRECTIVE) return;
-      const ctx = { atRule, onUnknown, result };
-      const parent = atRule.parent;
-      if (parent?.type !== "rule") {
-        reportUnknown("@nave must be the direct child of a CSS rule selector block", ctx);
-        atRule.remove();
-        return;
-      }
-      const rule = parent;
-      if (isInsideKeyframes(rule)) {
-        reportUnknown("@nave cannot be used inside @keyframes", ctx);
-        atRule.remove();
-        return;
-      }
-      const names = atRule.params.trim().split(/\s+/).filter(Boolean);
-      checkUnknownAtoms(names, validAtomNames, ctx);
-      const declNodes = [];
-      const nested = names.flatMap((name) => {
-        const atom = Object.hasOwn(allAtoms, name) ? allAtoms[name] : void 0;
-        if (!atom) return [];
-        if (typeof atom.declarations !== "object" || atom.declarations === null || Array.isArray(atom.declarations)) {
-          throw atRule.error(`@nave: atom "${name}" is registered without a declarations object`);
-        }
-        for (const [prop, value] of Object.entries(atom.declarations)) {
-          const decl = postcss.decl({ prop, value });
-          if (atRule.source) decl.source = atRule.source;
-          declNodes.push(decl);
+    // Per-run state lives here, not in the factory closure above: PostCSS
+    // calls `prepare(result)` once per `Result`, so two stylesheets sharing
+    // one `navePlugin()` instance never share a `fold` or a resolved
+    // `extend`, however their async hooks interleave (otherwise one
+    // stylesheet's problems, or its loaded `extend`, could leak into another's).
+    prepare(result) {
+      const fold = [];
+      let extend = staticExtend;
+      return {
+        Once() {
+          fold.length = 0;
+          if (extendFile === void 0) return;
+          result.messages.push({
+            type: "dependency",
+            plugin: "postcss-nave",
+            file: extendFile,
+            parent: result.opts.from
+          });
+          return applyExtendModule(extendFile, loadCache, (value) => {
+            const snapshot = snapshotExtendMap(value);
+            validateExtendAtoms(snapshot);
+            extend = snapshot;
+          });
+        },
+        AtRule(atRule) {
+          handleAtRule(atRule, { onUnknown, result, extend, fold });
+        },
+        OnceExit() {
+          if (fold.length === 0) return;
+          const ordered = sortFoldBySourceOrder(fold);
+          const first = ordered[0];
+          throw first.atRule.error(
+            foldMessage(ordered),
+            first.index === void 0 ? {} : { index: first.index }
+          );
         }
-        return buildNested(atom);
-      });
-      insertDeclarations(atRule, declNodes, isFollowingNestedNode(rule, atRule));
-      atRule.remove();
-      for (const node of nested) {
-        stampSource(node, atRule.source);
-        rule.append(node);
-      }
+      };
     }
   };
 };
 navePlugin.postcss = true;
+var postcss_default = navePlugin;
 
-export { navePlugin };
+export { postcss_default as default, navePlugin };