@animus-ui/layergate 0.0.0-stage → 0.1.35

package/dist/vite.cjs

@@ -0,0 +1,295 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_compile = require("./compile-C4GyCiuY.cjs");
+const require_sheet = require("./sheet-BUnyt5Jt.cjs");
+const require_plan = require("./plan-hvk04qzh.cjs");
+const require_host = require("./host-C4ZaMdkx.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_module = require("node:module");
+let vite = require("vite");
+//#region src/vite.ts
+/**
+* The Vite adapter. layergate owns the load of each selected stylesheet:
+* the declared sheets, which `virtual:layergate` (or a host's own
+* stylesheet, `declaredBy`) delivers as one finished stylesheet, and, opted
+* in, the `.css` a JS module imports from another package, which loads as
+* `<realpath>?layergate`. Each finished stylesheet has no local `@import`
+* left, and Vite's own CSS pipeline then processes it once: PostCSS,
+* minification, injection or extraction. A JS module's import of an owned
+* sheet reaches it through a proxy that imports the declared sheets first,
+* so they keep their order wherever the app imports an owned sheet first.
+* A stylesheet Vite loads itself that is owned, or reaches an owned file,
+* is finished in `transform`. CSS Modules and special requests (`?inline`,
+* `?url`, `?raw`) stay Vite's.
+*/
+const OWNED = "?layergate";
+const ENTRY_ID = "virtual:layergate";
+/** `virtual:layergate` is a stylesheet: the declared sheets, finished. */
+const RESOLVED_ENTRY = `\0${ENTRY_ID}.css`;
+/** A JS module's import of an owned sheet: the declared sheets, then it.
+*  Its id names the file encoded and ends in `.js`, so Vite never takes it
+*  for a stylesheet. */
+const PROXY = "\0layergate-proxy:";
+const proxyId = (file) => `${PROXY}${encodeURIComponent(file)}.js`;
+const proxiedFile = (id) => decodeURIComponent(id.slice(17, -3));
+const PLAIN_CSS = /\.css$/;
+const MODULE_CSS = /\.module\.css$/;
+/** The stylesheet a request id names when the request is plain stylesheet
+*  delivery: no query, or only Vite's `direct` (a stylesheet an HTML link
+*  loads in development) and its `t`/`v` cache-busting params. Special
+*  requests (`?inline`, `?url`, `?raw`) and CSS Modules are not. */
+function plainCssFile(id) {
+	const at = id.indexOf("?");
+	const path = at === -1 ? id : id.slice(0, at);
+	if (!PLAIN_CSS.test(path) || MODULE_CSS.test(path)) return null;
+	return (at === -1 ? [] : id.slice(at + 1).split("&")).every((param) => param === "direct" || /^[tv]=/.test(param)) ? path : null;
+}
+/** Whether `file` lies outside the directory `root`. */
+const outside = (root, file) => {
+	const path = (0, node_path.relative)(root, file);
+	return path.startsWith("..") || (0, node_path.isAbsolute)(path);
+};
+function layergate(options = {}) {
+	const plan = require_plan.resolvePlan(options);
+	const declaredBy = options.declaredBy ?? ENTRY_ID;
+	let root = process.cwd();
+	const owner = require_host.ownership(plan);
+	const { owns, owning } = owner;
+	/** `@import` inside an owned sheet resolves as Vite resolves a CSS
+	*  import: the `style` field and condition, CSS files only. */
+	let resolveCss;
+	/** Declared sheets, in order. */
+	let optedOut = /* @__PURE__ */ new Set();
+	/** Parsed files, the files each owned id's finished stylesheet read,
+	*  and reach answers. */
+	const units = new require_host.Units();
+	/** Each module's finished declared head, kept until a file it read
+	*  changes. */
+	const heads = /* @__PURE__ */ new Map();
+	let server;
+	/** Vite's watcher ignores node_modules, so an owned file there is
+	*  watched here through its directory, which sees edits, atomic saves,
+	*  deletion and creation alike, and its change handed to Vite's HMR. One
+	*  watch serves every owned file of a directory. */
+	const directories = /* @__PURE__ */ new Map();
+	const unwatch = (file) => {
+		const dir = (0, node_path.dirname)(file);
+		const watched = directories.get(dir);
+		watched?.files.delete(file);
+		if (watched?.files.size === 0) {
+			watched.watcher.close();
+			directories.delete(dir);
+		}
+	};
+	const watchInstalled = (file) => {
+		if (!server || !file.includes("/node_modules/")) return;
+		const dir = (0, node_path.dirname)(file);
+		const watched = directories.get(dir);
+		if (watched) {
+			watched.files.add(file);
+			return;
+		}
+		try {
+			const files = /* @__PURE__ */ new Set([file]);
+			const watcher = (0, node_fs.watch)(dir, (_event, name) => {
+				const changed = name ? `${dir}/${(0, node_path.basename)(name)}` : null;
+				if (changed && files.has(changed)) server?.watcher.emit("change", changed);
+			});
+			directories.set(dir, {
+				watcher,
+				files
+			});
+		} catch {}
+	};
+	/** Records the files `id`'s finished stylesheet read, forgetting and
+	*  unwatching what it no longer reads. */
+	const reconcile = (id, files) => {
+		for (const file of units.record(id, files)) unwatch(file);
+		for (const file of files) watchInstalled(file);
+	};
+	/** A root-relative URL for `target`, which Vite resolves from any
+	*  stylesheet, its own virtual ones too; one outside the root through
+	*  Vite's `/@fs/`, which the dev server serves only inside
+	*  `server.fs.allow`: the directory of an owned file outside it is
+	*  allowed, and nothing more. */
+	const rootUrl = (target) => {
+		if (!outside(require_host.real(root), target)) return `/${(0, vite.normalizePath)((0, node_path.relative)(require_host.real(root), target))}`;
+		if (server && !(0, vite.isFileLoadingAllowed)(server.config, (0, vite.normalizePath)(target))) server.config.server.fs.allow.push((0, vite.normalizePath)((0, node_path.dirname)(target)));
+		return `/@fs${(0, vite.normalizePath)(target)}`;
+	};
+	/** The file an `@import` in `importer` reaches, as Vite resolves CSS. */
+	const resolveImport = async (context, specifier, importer) => {
+		const resolved = await resolveCss?.(context.environment, specifier, importer);
+		return resolved && PLAIN_CSS.test(require_host.fileOf(resolved)) ? require_host.fileOf(resolved) : null;
+	};
+	/** Compiles `roots` with the host's CSS resolver, the plan and the
+	*  parsed-file cache. */
+	const finish = (context, roots, extra = {}) => require_compile.compileUnit(roots, {
+		layer: plan.layer,
+		order: plan.order,
+		base: root,
+		resolve: (specifier, from) => resolveImport(context, specifier, from),
+		read: (file) => (0, node_fs_promises.readFile)(file, "utf8"),
+		quarantined: (file) => !optedOut.has(file),
+		owns,
+		cache: units.parsed,
+		...extra
+	});
+	/** Reports `unit`'s diagnostics through `context` and records the files
+	*  module `id` now reads. */
+	const publish = (context, id, unit) => {
+		for (const file of unit.files) context.addWatchFile(file);
+		reconcile(id, unit.files);
+		for (const diagnostic of unit.diagnostics) {
+			const message = require_host.formatDiagnostic(diagnostic);
+			if (diagnostic.severity === "error") context.error(message);
+			else if (diagnostic.severity === "warning") context.warn(message);
+			else context.info(message);
+		}
+	};
+	/** The declared sheets as one finished stylesheet for module `id`, with
+	*  root-relative URLs; empty when nothing is declared. */
+	const head = async (context, id) => {
+		if (owner.declared.length === 0) return "";
+		const kept = heads.get(id);
+		if (kept !== void 0) return kept;
+		const unit = await finish(context, owner.declared, {
+			url: rootUrl,
+			map: false
+		});
+		publish(context, id, unit);
+		heads.set(id, unit.css);
+		return unit.css;
+	};
+	return Object.assign({
+		name: "layergate",
+		enforce: "pre",
+		config(userConfig, env) {
+			if (env.command !== "serve") return;
+			const base = (0, node_path.resolve)(userConfig.root ?? process.cwd());
+			const require$1 = (0, node_module.createRequire)((0, node_path.join)(base, "package.json"));
+			const dirs = [];
+			for (const specifier of plan.sheets) {
+				let file;
+				try {
+					file = require_host.real(specifier.startsWith(".") || (0, node_path.isAbsolute)(specifier) ? (0, node_path.resolve)(base, specifier) : require$1.resolve(specifier));
+				} catch {
+					continue;
+				}
+				if (outside(require_host.real(base), file)) dirs.push((0, node_path.dirname)(file));
+			}
+			if (dirs.length === 0) return;
+			return { server: { fs: { allow: userConfig.server?.fs?.allow ? dirs : [(0, vite.searchForWorkspaceRoot)(base), ...dirs] } } };
+		},
+		configResolved(config) {
+			root = config.root;
+			owner.reset(root, []);
+			resolveCss = (0, vite.createIdResolver)(config, {
+				extensions: [".css"],
+				mainFields: ["style"],
+				conditions: ["style", "development|production"],
+				tryIndex: false,
+				preferRelative: true
+			});
+		},
+		configureServer(devServer) {
+			server = devServer;
+		},
+		buildEnd() {
+			for (const { watcher } of directories.values()) watcher.close();
+			directories.clear();
+		},
+		async buildStart() {
+			const importer = (0, node_path.join)(root, "index.html");
+			const resolveOne = async (specifier) => {
+				const resolved = await this.resolve(specifier, importer, { skipSelf: true });
+				return resolved && !resolved.external ? require_host.fileOf(resolved.id) : null;
+			};
+			const declared = await require_host.resolveEach(plan.sheets, "sheets", root, resolveOne);
+			owner.reset(root, declared);
+			const cssModule = declared.find((file) => MODULE_CSS.test(file));
+			if (cssModule) this.error(`[layergate] sheets: ${cssModule} is a CSS Module; layergate does not own CSS Modules yet`);
+			optedOut = new Set(await require_host.resolveEach(plan.optOut, "optOut", root, resolveOne));
+			heads.clear();
+		},
+		async resolveId(source, importer, resolveOptions) {
+			if (source === ENTRY_ID) return RESOLVED_ENTRY;
+			if (source.endsWith(OWNED) || source.startsWith(PROXY)) return source;
+			if (!owning()) return null;
+			if (!importer || importer.startsWith("\0") || (0, vite.isCSSRequest)(importer)) return null;
+			if (source.includes("?") || !PLAIN_CSS.test(source)) return null;
+			const resolved = await this.resolve(source, importer, {
+				...resolveOptions,
+				skipSelf: true
+			});
+			if (!resolved || resolved.external) return null;
+			const file = require_host.fileOf(resolved.id);
+			if (!PLAIN_CSS.test(file) || MODULE_CSS.test(file)) return null;
+			return owns(file) ? proxyId(file) : null;
+		},
+		async load(id) {
+			if (id === RESOLVED_ENTRY) return head(this, id);
+			if (id.startsWith(PROXY)) {
+				const file = proxiedFile(id);
+				return (owner.declared.includes(file) ? [declaredBy] : [declaredBy, file + OWNED]).map((request) => `import ${JSON.stringify(request)};`).join("\n");
+			}
+			if (!id.endsWith(OWNED)) return null;
+			const unit = await finish(this, [id.slice(0, -10)]);
+			publish(this, id, unit);
+			return {
+				code: unit.css,
+				map: unit.map
+			};
+		},
+		async transform(code, id) {
+			if (!owning() || id.startsWith("\0")) return null;
+			const requested = plainCssFile(id);
+			if (!requested) return null;
+			const file = require_host.real(requested);
+			const { imports } = require_sheet.readSheet(code);
+			if (!owns(file) && imports.length === 0) return null;
+			if (!await units.reaches(file, imports, {
+				resolve: (specifier, from) => resolveImport(this, specifier, from),
+				read: (path) => (0, node_fs_promises.readFile)(path, "utf8"),
+				owns
+			})) return null;
+			units.parsed.delete(file);
+			const unit = await finish(this, [file], { read: (path) => path === file ? code : (0, node_fs_promises.readFile)(path, "utf8") });
+			publish(this, id, unit);
+			return {
+				code: unit.css,
+				map: unit.map
+			};
+		},
+		hotUpdate({ file, modules }) {
+			const stale = units.changed((0, vite.normalizePath)(file));
+			if (stale.size === 0) return;
+			const graph = this.environment.moduleGraph;
+			const affected = [];
+			for (const id of stale) {
+				heads.delete(id);
+				const node = graph.getModuleById(id);
+				if (!node) continue;
+				graph.invalidateModule(node);
+				affected.push(node);
+			}
+			return [...modules, ...affected];
+		}
+	}, { 
+	/**
+	* The declared sheets as one finished stylesheet, for a host that
+	* delivers them at the head of its own stylesheet module `id` (and
+	* names it `declaredBy`): URLs are root-relative, and an edit to any
+	* file read updates module `id`. Empty when nothing is declared.
+	*/
+stylesheetHead(id) {
+		return head(this, id);
+	} });
+}
+//#endregion
+exports.default = layergate;
+exports.layergate = layergate;

package/dist/vite.d.cts

@@ -0,0 +1,59 @@
+import { n as LayergateOptions } from "./plan-w-y0limy.cjs";
+import { EnvironmentModuleNode, Rolldown, ViteDevServer } from "vite";
+//#region src/vite.d.ts
+export interface LayergateViteOptions extends LayergateOptions {
+  /** The module that delivers the declared sheets; an owned stylesheet a
+   *  JS module imports loads it first. Default `virtual:layergate`. A host
+   *  that delivers them at the head of its own stylesheet
+   *  (`stylesheetHead`) names that stylesheet. */
+  declaredBy?: string;
+}
+export declare function layergate(options?: LayergateViteOptions): {
+  name: string;
+  enforce: "pre";
+  config(this: import("vite").ConfigPluginContext, userConfig: import("vite").UserConfig, env: import("vite").ConfigEnv): {
+    server: {
+      fs: {
+        allow: string[];
+      };
+    };
+  } | undefined;
+  configResolved(this: import("vite").MinimalPluginContextWithoutEnvironment, config: import("vite").ResolvedConfig): void;
+  configureServer(this: import("vite").MinimalPluginContextWithoutEnvironment, devServer: ViteDevServer): void;
+  buildEnd(): void;
+  buildStart(this: Rolldown.PluginContext): Promise<void>;
+  resolveId(this: Rolldown.PluginContext, source: string, importer: string | undefined, resolveOptions: {
+    kind?: Rolldown.ImportKind;
+    custom?: Rolldown.CustomPluginOptions;
+    ssr?: boolean | undefined;
+    isEntry: boolean;
+  }): Promise<string | null>;
+  load(this: Rolldown.PluginContext, id: string): Promise<string | {
+    code: string;
+    map: (Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+      sourcesContent: Array<string | null>;
+    }) | null;
+  } | null>;
+  transform(this: Rolldown.TransformPluginContext, code: string, id: string): Promise<{
+    code: string;
+    map: (Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+      sourcesContent: Array<string | null>;
+    }) | null;
+  } | null>;
+  hotUpdate(this: Rolldown.MinimalPluginContext & {
+    environment: import("vite").DevEnvironment;
+  }, { file, modules }: import("vite").HotUpdateOptions): EnvironmentModuleNode[] | undefined;
+} & {
+  /**
+   * The declared sheets as one finished stylesheet, for a host that
+   * delivers them at the head of its own stylesheet module `id` (and
+   * names it `declaredBy`): URLs are root-relative, and an edit to any
+   * file read updates module `id`. Empty when nothing is declared.
+   */
+  stylesheetHead(this: Rolldown.PluginContext, id: string): Promise<string>;
+};
+/** The plugin `layergate()` returns, its hooks typed as written. */
+export type LayergatePlugin = ReturnType<typeof layergate>;
+//#endregion
+export { type LayergateOptions, layergate as default };
+//# sourceMappingURL=vite.d.cts.map

package/dist/vite.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.cts","names":[],"sources":["../src/vite.ts"],"mappings":";;;iBAyDiB,6BAA6B;;;;;EAK5C;;wBAsCc,UAAU,UAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+TV,eAAA,MAAA,SAAS,eAAa,aAAe;;;YAOlD,kBAAkB,kBAAkB"}

package/dist/vite.d.mts

@@ -0,0 +1,59 @@
+import { n as LayergateOptions } from "./plan-w-y0limy.mjs";
+import { EnvironmentModuleNode, Rolldown, ViteDevServer } from "vite";
+//#region src/vite.d.ts
+export interface LayergateViteOptions extends LayergateOptions {
+  /** The module that delivers the declared sheets; an owned stylesheet a
+   *  JS module imports loads it first. Default `virtual:layergate`. A host
+   *  that delivers them at the head of its own stylesheet
+   *  (`stylesheetHead`) names that stylesheet. */
+  declaredBy?: string;
+}
+export declare function layergate(options?: LayergateViteOptions): {
+  name: string;
+  enforce: "pre";
+  config(this: import("vite").ConfigPluginContext, userConfig: import("vite").UserConfig, env: import("vite").ConfigEnv): {
+    server: {
+      fs: {
+        allow: string[];
+      };
+    };
+  } | undefined;
+  configResolved(this: import("vite").MinimalPluginContextWithoutEnvironment, config: import("vite").ResolvedConfig): void;
+  configureServer(this: import("vite").MinimalPluginContextWithoutEnvironment, devServer: ViteDevServer): void;
+  buildEnd(): void;
+  buildStart(this: Rolldown.PluginContext): Promise<void>;
+  resolveId(this: Rolldown.PluginContext, source: string, importer: string | undefined, resolveOptions: {
+    kind?: Rolldown.ImportKind;
+    custom?: Rolldown.CustomPluginOptions;
+    ssr?: boolean | undefined;
+    isEntry: boolean;
+  }): Promise<string | null>;
+  load(this: Rolldown.PluginContext, id: string): Promise<string | {
+    code: string;
+    map: (Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+      sourcesContent: Array<string | null>;
+    }) | null;
+  } | null>;
+  transform(this: Rolldown.TransformPluginContext, code: string, id: string): Promise<{
+    code: string;
+    map: (Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+      sourcesContent: Array<string | null>;
+    }) | null;
+  } | null>;
+  hotUpdate(this: Rolldown.MinimalPluginContext & {
+    environment: import("vite").DevEnvironment;
+  }, { file, modules }: import("vite").HotUpdateOptions): EnvironmentModuleNode[] | undefined;
+} & {
+  /**
+   * The declared sheets as one finished stylesheet, for a host that
+   * delivers them at the head of its own stylesheet module `id` (and
+   * names it `declaredBy`): URLs are root-relative, and an edit to any
+   * file read updates module `id`. Empty when nothing is declared.
+   */
+  stylesheetHead(this: Rolldown.PluginContext, id: string): Promise<string>;
+};
+/** The plugin `layergate()` returns, its hooks typed as written. */
+export type LayergatePlugin = ReturnType<typeof layergate>;
+//#endregion
+export { type LayergateOptions, layergate as default };
+//# sourceMappingURL=vite.d.mts.map

package/dist/vite.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.mts","names":[],"sources":["../src/vite.ts"],"mappings":";;;iBAyDiB,6BAA6B;;;;;EAK5C;;wBAsCc,UAAU,UAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+TV,eAAA,MAAA,SAAS,eAAa,aAAe;;;YAOlD,kBAAkB,kBAAkB"}