@navecss/core 0.3.0 → 0.4.0

package/README.md

@@ -21,7 +21,7 @@ pnpm add @navecss/core
   included, is reachable only through the package's `exports` map: there is no
   `main` field to fall back on.
 - **ES modules.** `@navecss/core/cx`, `@navecss/core/atoms`,
-  `@navecss/core/vite`, `@navecss/core/lightningcss` and `@navecss/core/check` load through `import` only. A `require()` of any of
+  `@navecss/core/vite`, `@navecss/core/lightningcss`, `@navecss/core/check` and `@navecss/core/collect` load through `import` only. A `require()` of any of
   them fails with `ERR_PACKAGE_PATH_NOT_EXPORTED`, which reads as though the
   entry point did not exist. In TypeScript, set `moduleResolution` to `bundler`,
   `node16` or `nodenext`; under `node10` their types are not found. A CommonJS
@@ -316,6 +316,21 @@ what `navePlugin()` does with no options. On the CSS-first path, where `@nave` c
 declarations into your own rule, a project that never calls `cx()` and writes no Nave class ships no
 rule from the atom layer.
 
+In a build, the plugin also turns each `cx()` call it read into the class string the call returns, so
+the map from atom names to classes does not ship: `cx('flex', 'grid')` becomes `"nave-flex nave-grid"`,
+and `cx('flex', on && 'grid')` becomes `["nave-flex", on && "nave-grid"].filter(Boolean).join(" ")`,
+with each argument evaluated once, in the order you wrote it. A direct `cx.raw()` call becomes the
+same join, and a direct `cx.dynamic()` call a lookup in a map of the atoms in `keep` and `keepFor`.
+The dev server keeps the run-time functions, which return the same strings. A bundle holds neither
+the name map nor the atoms' declarations when every use of `cx` in it is one of those direct calls
+and no module that imports `cx` calls `eval` directly. Two forms keep the map, since the build
+cannot follow the alias: `const r = cx.raw` and `const { raw } = cx`. So does a package listed in
+`keepFor` whose calls the build cannot read, because those calls stay calls to the run-time `cx()`.
+A module that calls `eval` directly keeps its import of `cx`, and with it the map, whatever text it
+runs (`eval('1')` too), because that text can read the module's names and the build cannot read the
+text. An indirect call, `(0, eval)(text)` or `globalThis.eval(text)`, runs its text in the global
+scope, where `cx` is not visible, and does not keep the import.
+
 So that nothing is dropped on a guess, a `cx()` call whose atoms the build cannot read fails the
 build. `vite build` reads every module first and fails once, at the end, with a report that lists
 each such use with its file, and its line and column when the source maps lead back to them, then
@@ -514,9 +529,10 @@ build, that list is the set of atoms its CSS holds, so you can diff it between b
 **Shipping every atom.** `navePlugin({ atomic: 'all' })` reads no `cx()` call and ships every atom,
 as the PostCSS plugin does. It suits a project whose Nave classes are mostly written where no build
 reads them, such as a backend's own templates or HTML from a CMS, where listing them in `keep` is
-not practical. It gives up what this section describes: no `cx()` call is read or checked, a name
-that is no atom passes through `cx()` as text, as it does without the plugin, and `cx.dynamic()`
-maps through every atom. The dev server serves every atom too, the plugin sets neither
+not practical. It gives up what this section describes: no `cx()` call is read, checked or turned
+into its class string, so the name map ships, a name that is no atom passes through `cx()` as text,
+as it does without the plugin, and `cx.dynamic()` maps through every atom. The dev server serves
+every atom too, the plugin sets neither
 `optimizeDeps.exclude` nor `resolve.noExternal`, no build writes `nave-used-atoms.json`, and
 `keep`, `keepFor` and `cxModules` are still checked for well-formed values and otherwise do nothing.
 It is also the way out that the plugin's own check names when a build's atom layer does not hold
@@ -879,3 +895,4 @@ Consumers of `@navecss/tokens` alone get no guide: it ships only in this package
 | `@navecss/core/standalone`   | The whole stylesheet in one file, with no `@import`, for projects with no bundler                     |
 | `@navecss/core/postcss`      | PostCSS plugin — `navePlugin()`                                                                       |
 | `@navecss/core/check`        | The survival check as a function — `check({ source })`                                                |
+| `@navecss/core/collect`      | Reads which atoms a module uses, for build tools; not meant for application code                      |

package/dist/atom-names-2OreuBx9.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The names of Nave's built-in atoms, and the class each one gets.
+ *
+ * cx() needs this and nothing else, so it lives apart from the declaration data in atoms.ts:
+ * a module that imports atoms.ts hands a consumer's bundler every atom's CSS declarations,
+ * not every bundler can drop them, and cx() would pay that for a name map.
+ *
+ * atoms.ts is checked against this list (`satisfies Record<AtomName, AtomDefinition>`), so
+ * an atom added there and missing here, or the other way round, fails the typecheck. Keep the
+ * two in the same order as well: atomic.css is written in the order of atoms.ts, the Vite
+ * plugin lists the atoms in the order of this list, and a test holds the two together.
+ */
+declare const atomNames: readonly ["flex", "inlineFlex", "grid", "block", "inlineBlock", "hidden", "flexCol", "flexWrap", "itemsCenter", "itemsStart", "itemsEnd", "justifyCenter", "justifyBetween", "justifyEnd", "flexGrow", "flexShrink0", "gap", "relative", "absolute", "insetFull", "wFull", "hFull", "minW0", "truncate", "srOnly", "srOnlyFocusable", "noWrap", "breakWord", "textLeft", "textCenter", "textRight", "interactive", "focusRing", "disabledState", "rounded", "roundedCard", "roundedFull", "border", "overflowHidden", "overflowAuto", "transition", "container", "hidePhoneOnly", "hideTabletPortraitUp", "hideTabletLandscapeUp", "hideDesktopUp", "stackPhoneOnly", "wFullPhoneOnly"];
+type AtomName = (typeof atomNames)[number];
+/**
+ * Converts a camelCase atom name to its nave-kebab-case CSS class name.
+ * focusRing → nave-focus-ring
+ */
+declare const toClassName: (name: AtomName) => string;
+/**
+ * Map of atom name → global CSS class name.
+ * 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>;
+
+export { type AtomName as A, atomClassMap as a, toClassName as t };

package/dist/atoms.d.ts

@@ -1,3 +1,5 @@
+export { A as AtomName, a as atomClassMap, t as toClassName } from './atom-names-2OreuBx9.js';
+
 type CSSDeclarations = Record<string, string>;
 type PseudoMap = Record<string, CSSDeclarations>;
 interface MediaBlock {
@@ -403,17 +405,5 @@ declare const atoms: {
         };
     };
 };
-type AtomName = keyof typeof atoms;
-/**
- * Converts a camelCase atom name to its nave-kebab-case CSS class name.
- * focusRing → nave-focus-ring
- */
-declare const toClassName: (name: AtomName) => string;
-/**
- * Map of atom name → global CSS class name.
- * 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>;
 
-export { type AtomDefinition, type AtomName, atomClassMap, atoms, toClassName };
+export { type AtomDefinition, atoms };

package/dist/atoms.js

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

package/dist/bin.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import { runCheck } from './chunk-XQQCDUV6.js';
-import { splitByteOrderMark, foldedText } from './chunk-IZQLFUQU.js';
+import { splitByteOrderMark, foldedText } from './chunk-2A7IUZBH.js';
 import { formatFinding } from './chunk-UANF3FGO.js';
-import { validateExtendAtomsHostFree } from './chunk-R6JJZGXC.js';
+import { validateExtendAtomsHostFree } from './chunk-LQSGQ2OA.js';
 import { resolveExtendSpecifier, applyExtendModule } from './chunk-NKUZNRF4.js';
-import { snapshotExtendMap, expandText } from './chunk-S7DZUVV3.js';
+import { snapshotExtendMap, expandText } from './chunk-LADFXRWQ.js';
 import { createPositionFinder, tokenize, atKeywordName } from './chunk-NFS2REPQ.js';
-import './chunk-LIUB4EES.js';
+import './chunk-SYNQJNVB.js';
+import './chunk-CUL5PLPI.js';
+import './chunk-GZL2VW7C.js';
 import { parseArgs } from 'util';
 import { realpathSync, watch, existsSync, statSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import path2 from 'path';

package/dist/{chunk-IZQLFUQU.js → chunk-2A7IUZBH.js}

@@ -1,4 +1,5 @@
-import { formatDiagnostic, foldLocated } from './chunk-S7DZUVV3.js';
+import { foldLocated } from './chunk-LADFXRWQ.js';
+import { formatDiagnostic } from './chunk-SYNQJNVB.js';
 
 // src/byte-order-mark.ts
 var BYTE_ORDER_MARK = "\uFEFF";

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

@@ -392,9 +392,5 @@ var atoms = {
     }
   }
 };
-var toClassName = (name) => `nave-${name.replaceAll(/([A-Z])/g, "-$1").toLowerCase()}`;
-var atomClassMap = Object.fromEntries(
-  Object.keys(atoms).map((name) => [name, toClassName(name)])
-);
 
-export { atomClassMap, atoms, toClassName };
+export { atoms };