boss-css 0.0.1 → 0.0.2

package/dist/api/css.mjs

@@ -0,0 +1,303 @@
+//#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
+export { CSS };

package/dist/api/dictionary.cjs

@@ -0,0 +1,218 @@
+
+//#region src/api/dictionary.ts
+var Dictionary = class Dictionary extends Map {
+	static Instance;
+	api;
+	constructor(api) {
+		super();
+		Dictionary.Instance = this;
+		this.api = api;
+	}
+	resolve(name) {
+		const direct = this.get(name);
+		if (direct) return {
+			descriptor: direct,
+			name,
+			raw: name,
+			suffix: null
+		};
+		if (typeof name !== "string") return {
+			descriptor: null,
+			name,
+			raw: name,
+			suffix: null
+		};
+		const underscoreIndex = name.indexOf("_");
+		if (underscoreIndex <= 0 || underscoreIndex === name.length - 1) return {
+			descriptor: null,
+			name,
+			raw: name,
+			suffix: null
+		};
+		const base = name.slice(0, underscoreIndex);
+		const suffix = name.slice(underscoreIndex + 1);
+		const descriptor = this.get(base);
+		if (!descriptor) return {
+			descriptor: null,
+			name,
+			raw: name,
+			suffix: null
+		};
+		return {
+			descriptor,
+			name: base,
+			raw: name,
+			suffix
+		};
+	}
+	set(key, value) {
+		for (const alias of value.aliases) super.set(alias, value);
+		return this;
+	}
+	toValue(value, property) {
+		const propertyName = typeof property === "string" ? property : property?.property ?? property?.aliases?.[0];
+		switch (true) {
+			case Array.isArray(value): return value.map((v) => this.toValue(v, property)).join(" ");
+			case typeof value === "number":
+			case isNumericValue(value): {
+				const numericValue = typeof value === "number" ? value : Number(value);
+				if (propertyName && unitlessProperties.has(propertyName)) return numericValue === 0 ? 0 : `${value}`;
+				return numericValue === 0 ? 0 : `${value}${this.api.unit}`;
+			}
+			default: return value;
+		}
+	}
+};
+const unitlessProperties = new Set([
+	"animationIterationCount",
+	"aspectRatio",
+	"borderImageOutset",
+	"borderImageSlice",
+	"borderImageWidth",
+	"boxFlex",
+	"boxFlexGroup",
+	"boxOrdinalGroup",
+	"columnCount",
+	"columns",
+	"flex",
+	"flexGrow",
+	"flexPositive",
+	"flexShrink",
+	"flexNegative",
+	"flexOrder",
+	"gridArea",
+	"gridRow",
+	"gridRowEnd",
+	"gridRowSpan",
+	"gridRowStart",
+	"gridColumn",
+	"gridColumnEnd",
+	"gridColumnSpan",
+	"gridColumnStart",
+	"fontWeight",
+	"lineClamp",
+	"lineHeight",
+	"opacity",
+	"order",
+	"orphans",
+	"scale",
+	"tabSize",
+	"widows",
+	"zIndex",
+	"zoom",
+	"fillOpacity",
+	"floodOpacity",
+	"stopOpacity",
+	"strokeDasharray",
+	"strokeDashoffset",
+	"strokeMiterlimit",
+	"strokeOpacity",
+	"strokeWidth",
+	"MozAnimationIterationCount",
+	"MozBoxFlex",
+	"MozBoxFlexGroup",
+	"MozLineClamp",
+	"msAnimationIterationCount",
+	"msFlex",
+	"msFlexGrow",
+	"msFlexNegative",
+	"msFlexOrder",
+	"msFlexPositive",
+	"msFlexShrink",
+	"msGridColumn",
+	"msGridColumnSpan",
+	"msGridRow",
+	"msGridRowSpan",
+	"msZoom",
+	"WebkitAnimationIterationCount",
+	"WebkitBoxFlex",
+	"WebkitBoxFlexGroup",
+	"WebkitBoxOrdinalGroup",
+	"WebkitColumnCount",
+	"WebkitColumns",
+	"WebkitFlex",
+	"WebkitFlexGrow",
+	"WebkitFlexPositive",
+	"WebkitFlexShrink",
+	"WebkitLineClamp",
+	"animation-iteration-count",
+	"aspect-ratio",
+	"border-image-outset",
+	"border-image-slice",
+	"border-image-width",
+	"box-flex",
+	"box-flex-group",
+	"box-ordinal-group",
+	"column-count",
+	"columns",
+	"flex",
+	"flex-grow",
+	"flex-positive",
+	"flex-shrink",
+	"flex-negative",
+	"flex-order",
+	"grid-area",
+	"grid-row",
+	"grid-row-end",
+	"grid-row-span",
+	"grid-row-start",
+	"grid-column",
+	"grid-column-end",
+	"grid-column-span",
+	"grid-column-start",
+	"font-weight",
+	"line-clamp",
+	"line-height",
+	"opacity",
+	"order",
+	"orphans",
+	"scale",
+	"tab-size",
+	"widows",
+	"z-index",
+	"zoom",
+	"fill-opacity",
+	"flood-opacity",
+	"stop-opacity",
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-miterlimit",
+	"stroke-opacity",
+	"stroke-width",
+	"-moz-animation-iteration-count",
+	"-moz-box-flex",
+	"-moz-box-flex-group",
+	"-moz-line-clamp",
+	"-ms-animation-iteration-count",
+	"-ms-flex",
+	"-ms-flex-grow",
+	"-ms-flex-negative",
+	"-ms-flex-order",
+	"-ms-flex-positive",
+	"-ms-flex-shrink",
+	"-ms-grid-column",
+	"-ms-grid-column-span",
+	"-ms-grid-row",
+	"-ms-grid-row-span",
+	"-ms-zoom",
+	"-webkit-animation-iteration-count",
+	"-webkit-box-flex",
+	"-webkit-box-flex-group",
+	"-webkit-box-ordinal-group",
+	"-webkit-column-count",
+	"-webkit-columns",
+	"-webkit-flex",
+	"-webkit-flex-grow",
+	"-webkit-flex-positive",
+	"-webkit-flex-shrink",
+	"-webkit-line-clamp"
+]);
+const isNumericValue = (value) => {
+	if (typeof value === "number") return true;
+	return /^-?\d+(?:\.\d+)?$/.test(value);
+};
+
+//#endregion
+exports.Dictionary = Dictionary;
+exports.isNumericValue = isNumericValue;
+exports.unitlessProperties = unitlessProperties;