@navecss/core 0.3.0 → 0.5.0

package/dist/vite.d.ts

@@ -1,4 +1,6 @@
-import { AtomName, AtomDefinition } from './atoms.js';
+import { AtomDefinition } from './atoms.js';
+import { UsedAtomOptions } from './collect.js';
+import './atom-names-B8Ud-7zD.js';
 
 /**
  * The few shapes of Vite's (and Rollup's) own objects the plugin touches, declared here rather
@@ -68,6 +70,9 @@ interface BuilderLike {
 interface EnvironmentLike {
     readonly name: string;
     readonly config: {
+        readonly build?: {
+            readonly emitAssets?: boolean;
+        };
         readonly command?: string;
         readonly consumer: string;
         readonly inlineConfig?: object;
@@ -213,74 +218,23 @@ interface BundleEntry {
     readonly type: string;
     readonly fileName: string;
     readonly source?: string | Uint8Array;
-}
-interface TransformResultLike {
-    readonly code: string;
-    readonly map: string;
-}
-
-/**
- * The options that choose which atoms the Vite plugin ships, and their validation. A value a
- * type would refuse in TypeScript is refused here too, so a JavaScript config gets the same
- * answer; every text opens `navePlugin(): `, the prefix of the plugin's config-level messages.
- */
-
-interface UsedAtomOptions {
-    /**
-     * Which atoms the build ships. `'used'` (the default): the atoms your `cx()` calls and your
-     * written Nave classes name, plus those in `keep` and `keepFor`. Under the default the build
-     * filters the atomic layer of every stylesheet it can reach, and the dev server serves the same
-     * set as far as it has read; a stylesheet imported with `?inline` or `?raw` ships every atom
-     * with a warning; a `cx()` call whose atoms the build cannot read fails the build, and is an
-     * error in the dev server.
-     * `'all'`: every atom, and no `cx()` call is read, as with the PostCSS plugin.
-     */
-    atomic?: 'all' | 'used';
-    /**
-     * Atoms always shipped, whether or not the build reads a use of them: every atom your own
-     * `cx.dynamic()` calls can take, and the atom of each Nave class written where the build cannot
-     * read it, such as in a server template or in CMS text.
-     */
-    keep?: readonly AtomName[];
     /**
-     * By package name: the atoms a dependency's own `cx()` calls can produce, for a package whose
-     * calls the build cannot read. They ship as if they were in `keep`, beside the atoms of the
-     * package's calls the build does read. The calls it cannot read are not changed, so any other
-     * atom they apply has no rule unless the build ships it for another reason. An empty list is
-     * accepted: it says those calls produce no atom, so the list adds none, and a `cx.dynamic()` call
-     * in the package still fails the build, as it does with no entry. A package in your own workspace
-     * is your code, not a dependency. The entry stands in for the package's own calls only: a
-     * re-export of `cx` in the package that the build reads and a module of yours takes (imports,
-     * re-exports or reads off a namespace, directly or through re-exports of it that the build reads,
-     * as `export ... from` or an import exported unchanged, in this package or another) still fails
-     * the build, because the calls your module makes through it would ship with no rule, and the
-     * message says how to clear it. Listing here a package that only re-exports it does not clear a
-     * take of yours, since a re-export is not a call. A server build that leaves the package external
-     * does not read it, so a take only your server code makes is judged by what the client build
-     * read: it fails the build as above when the client build read the re-export it takes and the
-     * build can read the take, and gets a warning naming `ssr.noExternal` when the build cannot tell,
-     * because no environment read the file the server loads, or your file reaches the package in a
-     * way the build cannot read as a take (a `require()`, say, or a `#` import); with separate client
-     * and server commands, the next client command judges what the last build of each server recorded
-     * of server files that still exist.
+     * The names an asset was emitted under, and the files it was made from: they survive a
+     * renaming of the file.
      */
-    keepFor?: Readonly<Record<string, readonly AtomName[]>>;
+    readonly names?: readonly string[];
+    readonly originalFileNames?: readonly string[];
     /**
-     * Modules that re-export `cx` from `@navecss/core/cx` unchanged, as
-     * `export { cx } from '@navecss/core/cx'`, in your code or in a dependency: a file that imports
-     * `cx` from one is read as if it imported it from `@navecss/core/cx`. The build follows a listed
-     * module one step. A relative entry (`'./src/ui/index.ts'`) is a path from Vite's `root`. A
-     * package name or subpath, an alias or an absolute path matches an import written the same way.
-     * A `#` entry matches an import written the same way only where that import resolves to a listed
-     * file, since a `#` import resolves through the `package.json` nearest the file that writes it.
-     * Every entry also matches an import that resolves to its file through a specifier naming that
-     * file or, for an `index` file, its directory; in your code, an import that reaches the file
-     * through any other specifier fails the build instead. A relative entry that resolves to no file
-     * is ignored, and so is an entry naming `@navecss/core/cx`, which the build always reads. The
-     * same setting, with the same entries, as `@navecss/eslint-plugin`'s `cxModules`, which reads a
-     * relative entry from the working directory instead of Vite's `root`.
+     * What a chunk holds, and the stylesheets it imports.
      */
-    cxModules?: readonly string[];
+    readonly modules?: Readonly<Record<string, unknown>>;
+    readonly viteMetadata?: {
+        readonly importedCss?: ReadonlySet<string>;
+    };
+}
+interface TransformResultLike {
+    readonly code: string;
+    readonly map: string;
 }
 
 interface HtmlHook {
@@ -292,10 +246,14 @@ interface HtmlHook {
 interface NaveCollectPlugin {
     readonly name: 'nave:collect';
     readonly enforce: 'post';
-    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<undefined>;
+    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<TransformResultLike | undefined>;
     readonly transformIndexHtml: HtmlHook;
     buildStart(this: RenderContext): Promise<void>;
     buildEnd(this: RenderContext, error?: unknown): Promise<void>;
+    readonly generateBundle: {
+        handler(this: BundleContext, options: unknown, bundle: Record<string, BundleEntry>): void;
+        readonly order: 'pre';
+    };
 }
 
 /**
@@ -310,7 +268,7 @@ interface NaveCollectPlugin {
 interface NaveWorkerPlugin {
     readonly name: 'nave:collect-worker';
     readonly enforce: 'post';
-    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<undefined>;
+    transform(this: TransformContext, code: string, id: string, meta?: TransformMeta): Promise<TransformResultLike | undefined>;
     buildEnd(this: RenderContext, error?: unknown): Promise<void>;
 }
 
@@ -427,4 +385,5 @@ type NavePlugins = [NaveVitePlugin, NaveCollectPlugin];
  */
 declare function navePlugin(options?: NaveViteOptions): NavePlugins;
 
-export { type NavePlugins, type NaveViteOptions, type NaveVitePlugin, navePlugin as default, navePlugin };
+export { navePlugin as default, navePlugin };
+export type { NavePlugins, NaveViteOptions, NaveVitePlugin };