boss-css 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1 @@
+boss-css

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,43 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__exportAll = __exportAll;
+exports.__toESM = __toESM;

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,20 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };

package/dist/api/browser.cjs

@@ -0,0 +1,54 @@
+const require_dictionary = require('./dictionary.cjs');
+const require_names = require('./names.cjs');
+const require_debug = require('../shared/debug.cjs');
+const require_browser = require('../log/browser.cjs');
+
+//#region src/api/browser.ts
+let api = null;
+function createApi(config, force = false) {
+	if (!force && api) return api;
+	const debug = require_debug.resolveDebugValue(config.debug);
+	const resolvedConfig = {
+		...config,
+		debug
+	};
+	const logRoot = require_browser.createLogger("boss", debug);
+	logRoot.child("api").log("Create browser API");
+	api = {
+		unit: "px",
+		trigger,
+		isBrowser: true,
+		log: logRoot,
+		...resolvedConfig,
+		plugins: Array.isArray(resolvedConfig.plugins) ? resolvedConfig.plugins : [],
+		contextToCSSVariable: require_names.contextToCSSVariable,
+		contextToClassName: require_names.contextToClassName,
+		camelCaseToDash: require_names.camelCaseToDash,
+		dashToCamelCase: require_names.dashToCamelCase
+	};
+	api.dictionary = new require_dictionary.Dictionary(api);
+	trigger("onInit");
+	return api;
+}
+function trigger(eventName, data, test = () => true) {
+	if (!api) return;
+	const currentApi = api;
+	const log = currentApi.log.child("api").child("trigger");
+	for (const plugin of currentApi.plugins) {
+		if (!plugin[eventName] || !test(plugin)) continue;
+		const handlers = Array.isArray(plugin[eventName]) ? plugin[eventName] : [plugin[eventName]];
+		for (const [index, handler] of Object.entries(handlers)) {
+			log.log(eventName, plugin.name, `${+index + 1}/${handlers.length}`);
+			handler(currentApi, data);
+		}
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'api', {
+  enumerable: true,
+  get: function () {
+    return api;
+  }
+});
+exports.createApi = createApi;

package/dist/api/browser.mjs

@@ -0,0 +1,48 @@
+import { Dictionary } from "./dictionary.mjs";
+import { camelCaseToDash, contextToCSSVariable, contextToClassName, dashToCamelCase } from "./names.mjs";
+import { resolveDebugValue } from "../shared/debug.mjs";
+import { createLogger } from "../log/browser.mjs";
+
+//#region src/api/browser.ts
+let api = null;
+function createApi(config, force = false) {
+	if (!force && api) return api;
+	const debug = resolveDebugValue(config.debug);
+	const resolvedConfig = {
+		...config,
+		debug
+	};
+	const logRoot = createLogger("boss", debug);
+	logRoot.child("api").log("Create browser API");
+	api = {
+		unit: "px",
+		trigger,
+		isBrowser: true,
+		log: logRoot,
+		...resolvedConfig,
+		plugins: Array.isArray(resolvedConfig.plugins) ? resolvedConfig.plugins : [],
+		contextToCSSVariable,
+		contextToClassName,
+		camelCaseToDash,
+		dashToCamelCase
+	};
+	api.dictionary = new Dictionary(api);
+	trigger("onInit");
+	return api;
+}
+function trigger(eventName, data, test = () => true) {
+	if (!api) return;
+	const currentApi = api;
+	const log = currentApi.log.child("api").child("trigger");
+	for (const plugin of currentApi.plugins) {
+		if (!plugin[eventName] || !test(plugin)) continue;
+		const handlers = Array.isArray(plugin[eventName]) ? plugin[eventName] : [plugin[eventName]];
+		for (const [index, handler] of Object.entries(handlers)) {
+			log.log(eventName, plugin.name, `${+index + 1}/${handlers.length}`);
+			handler(currentApi, data);
+		}
+	}
+}
+
+//#endregion
+export { api, createApi };

package/dist/api/config.cjs

@@ -0,0 +1,94 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_json = require('../shared/json.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let node_url = require("node:url");
+
+//#region src/api/config.ts
+const defaultConfig = {
+	configDir: ".bo$$",
+	unit: "px"
+};
+async function loadConfig(baseDir = process.cwd()) {
+	const packageJSONPath = node_path.default.join(baseDir, "package.json");
+	let packageJSON = {};
+	try {
+		packageJSON = require_json.parseJson(await node_fs_promises.default.readFile(packageJSONPath, "utf8"), {
+			filePath: packageJSONPath,
+			allowTrailingCommas: true
+		});
+	} catch {
+		packageJSON = {};
+	}
+	const rawPackageConfig = packageJSON["bo$$"];
+	const packageConfig = rawPackageConfig && typeof rawPackageConfig === "object" ? rawPackageConfig : {};
+	const config = {
+		...defaultConfig,
+		...packageConfig
+	};
+	const resolvedConfig = await resolveConfigPath(baseDir, config.configDir);
+	const userConfig = await loadUserConfig(resolvedConfig.userConfigPath);
+	const compile = {
+		tempOutDir: node_path.default.join(resolvedConfig.configDir, "compiled"),
+		...config.compile ?? {},
+		...userConfig.compile ?? {}
+	};
+	const css = {
+		...config.css ?? {},
+		...userConfig.css ?? {}
+	};
+	const runtime = {
+		...config.runtime ?? {},
+		...userConfig.runtime ?? {}
+	};
+	const plugins = Array.isArray(userConfig.plugins) ? userConfig.plugins : config.plugins ?? [];
+	return {
+		...config,
+		...userConfig,
+		css,
+		compile,
+		plugins,
+		runtime,
+		configDir: resolvedConfig.configDir,
+		stylesheetPath: node_path.default.join(baseDir, resolvedConfig.configDir, "styles.css")
+	};
+}
+async function loadUserConfig(userConfigPath) {
+	try {
+		await node_fs_promises.default.access(userConfigPath);
+	} catch {
+		return {};
+	}
+	return (await import((0, node_url.pathToFileURL)(userConfigPath).href)).default ?? {};
+}
+async function resolveConfigPath(baseDir, configDir) {
+	const primary = node_path.default.join(baseDir, configDir, "config.js");
+	if (await hasFile(primary)) return {
+		configDir,
+		userConfigPath: primary
+	};
+	if (configDir === ".bo$$") {
+		const fallback = node_path.default.join(baseDir, "src", ".bo$$", "config.js");
+		if (await hasFile(fallback)) return {
+			configDir: node_path.default.join("src", ".bo$$"),
+			userConfigPath: fallback
+		};
+	}
+	return {
+		configDir,
+		userConfigPath: primary
+	};
+}
+async function hasFile(filePath) {
+	try {
+		await node_fs_promises.default.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+exports.loadConfig = loadConfig;

package/dist/api/config.mjs

@@ -0,0 +1,91 @@
+import { parseJson } from "../shared/json.mjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region src/api/config.ts
+const defaultConfig = {
+	configDir: ".bo$$",
+	unit: "px"
+};
+async function loadConfig(baseDir = process.cwd()) {
+	const packageJSONPath = path.join(baseDir, "package.json");
+	let packageJSON = {};
+	try {
+		packageJSON = parseJson(await fs.readFile(packageJSONPath, "utf8"), {
+			filePath: packageJSONPath,
+			allowTrailingCommas: true
+		});
+	} catch {
+		packageJSON = {};
+	}
+	const rawPackageConfig = packageJSON["bo$$"];
+	const packageConfig = rawPackageConfig && typeof rawPackageConfig === "object" ? rawPackageConfig : {};
+	const config = {
+		...defaultConfig,
+		...packageConfig
+	};
+	const resolvedConfig = await resolveConfigPath(baseDir, config.configDir);
+	const userConfig = await loadUserConfig(resolvedConfig.userConfigPath);
+	const compile = {
+		tempOutDir: path.join(resolvedConfig.configDir, "compiled"),
+		...config.compile ?? {},
+		...userConfig.compile ?? {}
+	};
+	const css = {
+		...config.css ?? {},
+		...userConfig.css ?? {}
+	};
+	const runtime = {
+		...config.runtime ?? {},
+		...userConfig.runtime ?? {}
+	};
+	const plugins = Array.isArray(userConfig.plugins) ? userConfig.plugins : config.plugins ?? [];
+	return {
+		...config,
+		...userConfig,
+		css,
+		compile,
+		plugins,
+		runtime,
+		configDir: resolvedConfig.configDir,
+		stylesheetPath: path.join(baseDir, resolvedConfig.configDir, "styles.css")
+	};
+}
+async function loadUserConfig(userConfigPath) {
+	try {
+		await fs.access(userConfigPath);
+	} catch {
+		return {};
+	}
+	return (await import(pathToFileURL(userConfigPath).href)).default ?? {};
+}
+async function resolveConfigPath(baseDir, configDir) {
+	const primary = path.join(baseDir, configDir, "config.js");
+	if (await hasFile(primary)) return {
+		configDir,
+		userConfigPath: primary
+	};
+	if (configDir === ".bo$$") {
+		const fallback = path.join(baseDir, "src", ".bo$$", "config.js");
+		if (await hasFile(fallback)) return {
+			configDir: path.join("src", ".bo$$"),
+			userConfigPath: fallback
+		};
+	}
+	return {
+		configDir,
+		userConfigPath: primary
+	};
+}
+async function hasFile(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { loadConfig };

package/dist/api/css.cjs

@@ -0,0 +1,304 @@
+
+//#region src/api/css.ts
+var CSS = class extends Set {
+	api;
+	log;
+	current = null;
+	source = null;
+	ruleMeta = /* @__PURE__ */ new Map();
+	ruleSources = /* @__PURE__ */ new Map();
+	ruleIndex = 0;
+	imports = /* @__PURE__ */ new Set();
+	customBlocks = /* @__PURE__ */ new Map();
+	customByFile = /* @__PURE__ */ new Map();
+	rootSources = /* @__PURE__ */ new Map();
+	get text() {
+		const importRules = this.imports.size ? Array.from(this.imports).join("\n") : "";
+		const entries = Array.from(this).map((rule) => {
+			const meta = this.ruleMeta.get(rule);
+			return {
+				rule,
+				query: meta?.query ?? null,
+				index: meta?.index ?? 0
+			};
+		});
+		const baseRules = entries.filter((entry) => !entry.query).sort((a, b) => a.index - b.index).map((entry) => entry.rule);
+		const atRules = entries.filter((entry) => entry.query).sort((a, b) => this.compareAtRuleOrder(a, b)).map((entry) => entry.rule);
+		const orderedRules = [...baseRules, ...atRules].join("\n");
+		const rootRules = this.root.size ? `${this.api.selectorScope || ":root"} {
+  ${Array.from(this.root).join("\n  ")}
+}
+${orderedRules}` : orderedRules;
+		const customRules = this.getCustomText();
+		if (!importRules && !rootRules && !customRules) return "";
+		if (!importRules && !customRules) return rootRules;
+		if (!importRules && !rootRules) return customRules;
+		if (!customRules) return importRules ? `${importRules}\n${rootRules}` : rootRules;
+		if (!rootRules) return importRules ? `${importRules}\n${customRules}` : customRules;
+		return `${importRules}\n${rootRules}\n${customRules}`;
+	}
+	root = /* @__PURE__ */ new Set();
+	constructor(api) {
+		super();
+		this.api = api;
+		this.log = api.log.child("css");
+	}
+	setSource(source) {
+		this.source = source;
+	}
+	rule(property, value, options) {
+		if (!this.current) throw new Error("CSS:rule No current selector");
+		const suffix = options?.important ? " !important" : "";
+		this.current.values.add(`${property}: ${this.api.dictionary.toValue(value, property)}${suffix}`);
+	}
+	addImport(url) {
+		if (!url) return;
+		this.imports.add(`@import url("${url}");`);
+	}
+	addRule(rule, query = null, source = null) {
+		const wrapped = query ? `${query} { ${rule} }` : rule;
+		if (!this.has(wrapped)) {
+			this.add(wrapped);
+			this.ruleMeta.set(wrapped, {
+				query,
+				index: this.ruleIndex
+			});
+			this.ruleIndex += 1;
+		}
+		this.trackRuleSource(wrapped, source ?? this.source);
+	}
+	selector({ className, selector = null, pseudos = [], query = null, source = null }) {
+		this.log.log("selector", {
+			className,
+			selector,
+			pseudos,
+			query
+		});
+		if (!this.current) this.current = {
+			className: null,
+			selector: null,
+			pseudos: [],
+			values: /* @__PURE__ */ new Set(),
+			query: null,
+			source: null
+		};
+		const current = this.current;
+		if (query && current.query && query !== current.query) throw new Error(`CSS:selector Selector already has a query. Existing: ${current.query} Incoming: ${query}`);
+		const mergedPseudos = [];
+		for (const pseudo of [...current.pseudos, ...pseudos]) if (!mergedPseudos.includes(pseudo)) mergedPseudos.push(pseudo);
+		const next = {
+			pseudos: mergedPseudos,
+			query: query || current.query
+		};
+		if (selector) Object.assign(next, {
+			selector,
+			className: null
+		});
+		else if (className) Object.assign(next, { className });
+		if (source || this.source) next.source = source ?? this.source;
+		Object.assign(current, next);
+	}
+	write() {
+		this.log.log("write", this.current);
+		if (!this.current) throw new Error("CSS:write No current selector");
+		const current = this.current;
+		const baseSelector = current.selector || (current.className ? `.${current.className}` : null);
+		if (!baseSelector) throw new Error("CSS:write No className or selector");
+		const selector = [baseSelector, ...current.pseudos].join(":");
+		const selectorScope = typeof this.api.selectorScope === "string" ? this.api.selectorScope : "";
+		let string = `${selectorScope ? `${selectorScope}${selector}` : selector} { ${[...current.values].join(";")} }`;
+		if (current.query) string = `${current.query} { ${string} }`;
+		if (!this.has(string)) {
+			this.add(string);
+			this.ruleMeta.set(string, {
+				query: current.query,
+				index: this.ruleIndex
+			});
+			this.ruleIndex += 1;
+		}
+		this.trackRuleSource(string, current.source ?? this.source);
+		this.current = null;
+	}
+	compareAtRuleOrder(a, b) {
+		const aOrder = this.getAtRuleOrder(a.query, a.index);
+		const bOrder = this.getAtRuleOrder(b.query, b.index);
+		if (aOrder.group !== bOrder.group) return aOrder.group - bOrder.group;
+		if (aOrder.primary !== bOrder.primary) return aOrder.primary - bOrder.primary;
+		if (aOrder.secondary !== bOrder.secondary) return aOrder.secondary - bOrder.secondary;
+		return aOrder.index - bOrder.index;
+	}
+	getAtRuleOrder(query, index) {
+		if (!query) return {
+			group: 0,
+			primary: 0,
+			secondary: 0,
+			index
+		};
+		const normalized = query.trim().toLowerCase();
+		if (!normalized.startsWith("@media")) return {
+			group: 4,
+			primary: 0,
+			secondary: 0,
+			index
+		};
+		const minMatch = normalized.match(/min-width\s*:\s*(\d+(?:\.\d+)?)px/);
+		const maxMatch = normalized.match(/max-width\s*:\s*(\d+(?:\.\d+)?)px/);
+		const min = minMatch ? Number(minMatch[1]) : null;
+		const max = maxMatch ? Number(maxMatch[1]) : null;
+		if (min !== null && max !== null) return {
+			group: 1,
+			primary: min,
+			secondary: max,
+			index
+		};
+		if (max !== null) return {
+			group: 0,
+			primary: -max,
+			secondary: 0,
+			index
+		};
+		if (min !== null) return {
+			group: 2,
+			primary: min,
+			secondary: 0,
+			index
+		};
+		return {
+			group: 3,
+			primary: 0,
+			secondary: 0,
+			index
+		};
+	}
+	addRoot(value, source = null) {
+		if (!value) return;
+		this.root.add(value);
+		this.trackRootSource(value, source ?? this.source);
+	}
+	removeSource(source) {
+		if (!source) return;
+		for (const [rule, sources] of this.ruleSources.entries()) {
+			if (!sources.delete(source)) continue;
+			if (sources.size === 0) {
+				this.ruleSources.delete(rule);
+				this.ruleMeta.delete(rule);
+				this.delete(rule);
+			}
+		}
+		for (const [declaration, sources] of this.rootSources.entries()) {
+			if (!sources.delete(source)) continue;
+			if (sources.size === 0) {
+				this.rootSources.delete(declaration);
+				this.root.delete(declaration);
+			}
+		}
+		const customIds = this.customByFile.get(source);
+		if (customIds) {
+			for (const id of customIds) this.customBlocks.delete(id);
+			this.customByFile.delete(source);
+		}
+	}
+	reset() {
+		this.clear();
+		this.root.clear();
+		this.imports.clear();
+		this.customBlocks.clear();
+		this.customByFile.clear();
+		this.ruleMeta.clear();
+		this.ruleSources.clear();
+		this.rootSources.clear();
+		this.ruleIndex = 0;
+		this.current = null;
+		this.source = null;
+	}
+	snapshot() {
+		const cloneSet = (set) => new Set(set);
+		const cloneSetMap = (map) => {
+			const next = /* @__PURE__ */ new Map();
+			for (const [key, value] of map.entries()) next.set(key, new Set(value));
+			return next;
+		};
+		const cloneRuleMeta = /* @__PURE__ */ new Map();
+		for (const [key, meta] of this.ruleMeta.entries()) cloneRuleMeta.set(key, {
+			query: meta.query ?? null,
+			index: meta.index
+		});
+		const cloneCustomBlocks = /* @__PURE__ */ new Map();
+		for (const [key, value] of this.customBlocks.entries()) cloneCustomBlocks.set(key, { ...value });
+		const cloneCustomByFile = /* @__PURE__ */ new Map();
+		for (const [key, value] of this.customByFile.entries()) cloneCustomByFile.set(key, new Set(value));
+		return {
+			rules: cloneSet(this),
+			root: cloneSet(this.root),
+			imports: cloneSet(this.imports),
+			ruleMeta: cloneRuleMeta,
+			ruleSources: cloneSetMap(this.ruleSources),
+			rootSources: cloneSetMap(this.rootSources),
+			customBlocks: cloneCustomBlocks,
+			customByFile: cloneCustomByFile,
+			ruleIndex: this.ruleIndex
+		};
+	}
+	restore(snapshot) {
+		const data = snapshot;
+		if (!data) return;
+		this.reset();
+		for (const rule of data.rules ?? []) this.add(rule);
+		for (const value of data.root ?? []) this.root.add(value);
+		for (const value of data.imports ?? []) this.imports.add(value);
+		if (data.ruleMeta) this.ruleMeta = new Map(data.ruleMeta);
+		if (data.ruleSources) this.ruleSources = new Map(data.ruleSources);
+		if (data.rootSources) this.rootSources = new Map(data.rootSources);
+		if (data.customBlocks) this.customBlocks = new Map(data.customBlocks);
+		if (data.customByFile) this.customByFile = new Map(data.customByFile);
+		this.ruleIndex = data.ruleIndex ?? 0;
+	}
+	syncCustomBlocks(file, blocks) {
+		const fileKey = file || "<unknown>";
+		const nextIds = /* @__PURE__ */ new Set();
+		for (const block of blocks) {
+			const cssText = block.cssText;
+			if (!cssText.trim()) continue;
+			const id = `${fileKey}:${block.start}-${block.end}`;
+			nextIds.add(id);
+			const existing = this.customBlocks.get(id);
+			if (!existing || existing.cssText !== cssText) this.customBlocks.set(id, {
+				cssText,
+				file: fileKey,
+				start: block.start,
+				end: block.end
+			});
+		}
+		const previous = this.customByFile.get(fileKey);
+		if (previous) {
+			for (const id of previous) if (!nextIds.has(id)) this.customBlocks.delete(id);
+		}
+		if (nextIds.size) this.customByFile.set(fileKey, nextIds);
+		else this.customByFile.delete(fileKey);
+	}
+	getCustomText() {
+		if (!this.customBlocks.size) return "";
+		return Array.from(this.customBlocks.values()).map((entry) => entry.cssText).join("\n");
+	}
+	trackRuleSource(rule, source) {
+		if (!source) return;
+		const existing = this.ruleSources.get(rule);
+		if (existing) {
+			existing.add(source);
+			return;
+		}
+		this.ruleSources.set(rule, new Set([source]));
+	}
+	trackRootSource(rule, source) {
+		if (!source) return;
+		const existing = this.rootSources.get(rule);
+		if (existing) {
+			existing.add(source);
+			return;
+		}
+		this.rootSources.set(rule, new Set([source]));
+	}
+};
+
+//#endregion
+exports.CSS = CSS;