@navita/engine 0.2.2 → 3.0.0-next.1

package/identifiers/alphaIDGenerator.mjs

@@ -1,25 +1,26 @@
-const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-const charLength = chars.length;
-class AlphaIDGenerator {
-    constructor(blacklist = [
-        'ad'
-    ]){
-        this.blacklist = blacklist;
-        this.counter = 1;
-    }
-    next() {
-        const nextString = (id, className = '')=>{
-            if (id <= charLength) {
-                return chars[id - 1] + className;
-            }
-            return nextString(id / charLength | 0, chars[(id - 1) % charLength] + className);
-        };
-        let className;
-        do {
-            className = nextString(this.counter++);
-        }while (this.blacklist.includes(className.toLowerCase()))
-        return className;
-    }
-}
-
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/identifiers/alphaIDGenerator.ts
+const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const charLength = 52;
+var AlphaIDGenerator = class {
+	blacklist;
+	counter = 1;
+	constructor(blacklist = ["ad"]) {
+		this.blacklist = blacklist;
+	}
+	next() {
+		const nextString = (id, className = "") => {
+			if (id <= charLength) return chars[id - 1] + className;
+			return nextString(id / charLength | 0, chars[(id - 1) % charLength] + className);
+		};
+		let className;
+		do
+			className = nextString(this.counter++);
+		while (this.blacklist.includes(className.toLowerCase()));
+		return className;
+	}
+};
+//#endregion
 export { AlphaIDGenerator };

package/identifiers/propertyValueIDGenerator.cjs

@@ -1,24 +1,19 @@
-'use strict';
-
-var alphaIDGenerator = require('./alphaIDGenerator.cjs');
-
-class PropertyValueIDGenerator {
-    property = new alphaIDGenerator.AlphaIDGenerator();
-    cache = {};
-    next({ property , media ='' , support ='' , container ='' , pseudo ='' , value  }) {
-        const propertyKey = `m${media}s${support}c${container}ps${pseudo}p${property}`;
-        if (this.cache[propertyKey] === undefined) {
-            this.cache[propertyKey] = {
-                key: this.property.next(),
-                cache: {}
-            };
-        }
-        const entry = this.cache[propertyKey];
-        if (entry.cache[value] === undefined) {
-            entry.cache[value] = Object.keys(entry.cache).length + 1;
-        }
-        return `${entry.key}${entry.cache[value]}`;
-    }
-}
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_identifiers_alphaIDGenerator = require("./alphaIDGenerator.cjs");
+//#region src/identifiers/propertyValueIDGenerator.ts
+var PropertyValueIDGenerator = class {
+	property = new require_identifiers_alphaIDGenerator.AlphaIDGenerator();
+	cache = {};
+	next({ property, media = "", support = "", container = "", pseudo = "", value }) {
+		const propertyKey = `m${media}s${support}c${container}ps${pseudo}p${property}`;
+		if (this.cache[propertyKey] === void 0) this.cache[propertyKey] = {
+			key: this.property.next(),
+			cache: {}
+		};
+		const entry = this.cache[propertyKey];
+		if (entry.cache[value] === void 0) entry.cache[value] = Object.keys(entry.cache).length + 1;
+		return `${entry.key}${entry.cache[value]}`;
+	}
+};
+//#endregion
 exports.PropertyValueIDGenerator = PropertyValueIDGenerator;

package/identifiers/propertyValueIDGenerator.mjs

@@ -1,22 +1,21 @@
-import { AlphaIDGenerator } from './alphaIDGenerator.mjs';
-
-class PropertyValueIDGenerator {
-    property = new AlphaIDGenerator();
-    cache = {};
-    next({ property , media ='' , support ='' , container ='' , pseudo ='' , value  }) {
-        const propertyKey = `m${media}s${support}c${container}ps${pseudo}p${property}`;
-        if (this.cache[propertyKey] === undefined) {
-            this.cache[propertyKey] = {
-                key: this.property.next(),
-                cache: {}
-            };
-        }
-        const entry = this.cache[propertyKey];
-        if (entry.cache[value] === undefined) {
-            entry.cache[value] = Object.keys(entry.cache).length + 1;
-        }
-        return `${entry.key}${entry.cache[value]}`;
-    }
-}
-
+import "node:path";
+import "node:url";
+import.meta.url;
+import { AlphaIDGenerator } from "./alphaIDGenerator.mjs";
+//#region src/identifiers/propertyValueIDGenerator.ts
+var PropertyValueIDGenerator = class {
+	property = new AlphaIDGenerator();
+	cache = {};
+	next({ property, media = "", support = "", container = "", pseudo = "", value }) {
+		const propertyKey = `m${media}s${support}c${container}ps${pseudo}p${property}`;
+		if (this.cache[propertyKey] === void 0) this.cache[propertyKey] = {
+			key: this.property.next(),
+			cache: {}
+		};
+		const entry = this.cache[propertyKey];
+		if (entry.cache[value] === void 0) entry.cache[value] = Object.keys(entry.cache).length + 1;
+		return `${entry.key}${entry.cache[value]}`;
+	}
+};
+//#endregion
 export { PropertyValueIDGenerator };

package/index.cjs

@@ -1,241 +1,190 @@
-'use strict';
-
-var path = require('node:path');
-var hash = require('@emotion/hash');
-var cache = require('./cache.cjs');
-var isObject = require('./helpers/isObject.cjs');
-var splitStyleBlocks = require('./helpers/splitStyleBlocks.cjs');
-var IDGenerator = require('./identifiers/IDGenerator.cjs');
-var alphaIDGenerator = require('./identifiers/alphaIDGenerator.cjs');
-var propertyValueIDGenerator = require('./identifiers/propertyValueIDGenerator.cjs');
-var printFontFaces = require('./printers/printFontFaces.cjs');
-var printKeyFrames = require('./printers/printKeyFrames.cjs');
-var printSourceMap = require('./printers/printSourceMap.cjs');
-var printStyleBlocks = require('./printers/printStyleBlocks.cjs');
-var sortAtRules = require('./printers/sortAtRules.cjs');
-var processKeyframes = require('./processKeyframes.cjs');
-var processStyles = require('./processStyles.cjs');
-var classList = require('./wrappers/classList.cjs');
-var _static = require('./wrappers/static.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_cache = require("./cache.cjs");
+const require_helpers_isObject = require("./helpers/isObject.cjs");
+const require_helpers_splitStyleBlocks = require("./helpers/splitStyleBlocks.cjs");
+const require_identifiers_alphaIDGenerator = require("./identifiers/alphaIDGenerator.cjs");
+const require_identifiers_IDGenerator = require("./identifiers/IDGenerator.cjs");
+const require_identifiers_propertyValueIDGenerator = require("./identifiers/propertyValueIDGenerator.cjs");
+const require_printers_printFontFaces = require("./printers/printFontFaces.cjs");
+const require_printers_printKeyFrames = require("./printers/printKeyFrames.cjs");
+const require_printers_printSourceMap = require("./printers/printSourceMap.cjs");
+const require_printers_printStyleBlocks = require("./printers/printStyleBlocks.cjs");
+const require_printers_sortAtRules = require("./printers/sortAtRules.cjs");
+const require_processKeyframes = require("./processKeyframes.cjs");
+const require_processStyles = require("./processStyles.cjs");
+const require_wrappers_classList = require("./wrappers/classList.cjs");
+const require_wrappers_static = require("./wrappers/static.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let _emotion_hash = require("@emotion/hash");
+_emotion_hash = require_runtime.__toESM(_emotion_hash);
+//#region src/index.ts
 const defaultOptions = {
-    enableSourceMaps: false,
-    enableDebugIdentifiers: false
+	enableSourceMaps: false,
+	enableDebugIdentifiers: false
 };
-class Engine {
-    caches = {
-        rule: new cache.Cache(new propertyValueIDGenerator.PropertyValueIDGenerator()),
-        static: new cache.Cache(new IDGenerator.IDGenerator()),
-        keyframes: new cache.Cache(new alphaIDGenerator.AlphaIDGenerator()),
-        fontFace: new cache.Cache(new alphaIDGenerator.AlphaIDGenerator()),
-        identifiers: new cache.Cache(new alphaIDGenerator.AlphaIDGenerator())
-    };
-    usedIds = {};
-    identifierCount = 0;
-    options = {};
-    sourceMapReferences = {};
-    constructor(options = {}){
-        this.options = {
-            ...defaultOptions,
-            ...Object.keys(options).reduce((acc, key)=>{
-                if (options[key] !== undefined) {
-                    acc[key] = options[key];
-                }
-                return acc;
-            }, {})
-        };
-    }
-    addStatic(selector, styles) {
-        this.addUsedIds("static", processStyles.processStyles({
-            type: "static",
-            cache: this.caches.static
-        })({
-            styles,
-            selector
-        }).map((style)=>style.id));
-        return new _static.Static();
-    }
-    addStyle(styles) {
-        const rules = processStyles.processStyles({
-            type: "rule",
-            cache: this.caches.rule
-        })({
-            styles
-        });
-        const ids = rules.map((rule)=>rule.id);
-        this.addUsedIds("rule", ids);
-        return new classList.ClassList(ids.join(" "));
-    }
-    addFontFace(fontFace) {
-        const { id  } = this.caches.fontFace.getOrStore({
-            type: "fontFace",
-            rule: Array.isArray(fontFace) ? fontFace : [
-                fontFace
-            ]
-        });
-        this.addUsedIds("fontFace", [
-            id
-        ]);
-        return id;
-    }
-    addKeyframes(keyframes) {
-        const { id  } = this.caches.keyframes.getOrStore({
-            type: "keyframes",
-            rule: processKeyframes.processKeyframes(keyframes)
-        });
-        this.addUsedIds("keyframes", [
-            id
-        ]);
-        return id;
-    }
-    addSourceMapReference({ filePath , identifier , classList , line , column , index  }) {
-        if (!this.options.enableSourceMaps) {
-            return false;
-        }
-        const { name  } = path.parse(filePath);
-        const extraClass = this.options.enableDebugIdentifiers ? `${name}_${identifier}` : '';
-        const selector = '.' + classList.toString().split(' ').concat(extraClass).filter(Boolean).join('.');
-        const newFilePath = path.relative(this.options.context || process.cwd(), filePath);
-        if (index === 0 || !this.sourceMapReferences[newFilePath]) {
-            this.sourceMapReferences[newFilePath] = [];
-        }
-        this.sourceMapReferences[newFilePath][index] = {
-            selector,
-            line,
-            column
-        };
-        return extraClass;
-    }
-    clearSourceMapReferences(filePath) {
-        const newFilePath = path.relative(this.options.context || process.cwd(), filePath);
-        this.sourceMapReferences[newFilePath] = [];
-    }
-    clearCache(filePath) {
-        this.clearUsedIds(filePath);
-        this.clearSourceMapReferences(filePath);
-    }
-    generateIdentifier(value) {
-        if (typeof value === 'undefined') {
-            let identifier = hash((this.identifierCount++).toString(36));
-            if (identifier.match(/^\d/)) {
-                identifier = `_${identifier}`;
-            }
-            return identifier;
-        }
-        const newValue = JSON.stringify(value);
-        const { id  } = this.caches.identifiers.getOrStore({
-            value: newValue
-        });
-        this.addUsedIds("identifiers", [
-            id
-        ]);
-        return `_${id}`;
-    }
-    renderCssToString(options) {
-        const { filePaths , usedIds , opinionatedLayers =false  } = options || {};
-        // We prioritize ids over filePaths. If neither are provided, we use all the used filePaths.
-        const { keyframes: keyframesCache , fontFace: fontFaceCache , static: staticCache , rule: ruleCache  } = usedIds ?? this.getCacheIds(filePaths ?? Object.keys(this.usedIds));
-        const { atRules , lowPrioRules , rules  } = splitStyleBlocks.splitStyleBlocks(this.caches.rule.items(ruleCache));
-        const keyFrameCss = printKeyFrames.printKeyFrames(this.caches.keyframes.items(keyframesCache));
-        const fontFaceCss = printFontFaces.printFontFaces(this.caches.fontFace.items(fontFaceCache));
-        const staticCss = printStyleBlocks.printStyleBlocks(this.caches.static.items(staticCache));
-        const atRulesCss = printStyleBlocks.printStyleBlocks(sortAtRules.sortAtRules(atRules));
-        const lowPrioRulesCss = printStyleBlocks.printStyleBlocks(lowPrioRules);
-        const rulesCss = printStyleBlocks.printStyleBlocks(rules);
-        if (opinionatedLayers) {
-            const result = `${keyFrameCss}${fontFaceCss}` + (staticCss.length > 0 ? `@layer s{${staticCss}}` : '') + (lowPrioRulesCss.length > 0 ? `@layer lpr{${lowPrioRulesCss}}` : '') + (rulesCss.length > 0 ? `@layer r{${rulesCss}}` : '') + (atRulesCss.length > 0 ? `@layer at{${atRulesCss}}` : '');
-            if (result.length > 0) {
-                // s - static
-                // lpr - low priority rules
-                // r - rules
-                // at - at rules
-                return `@layer s,lpr,r,at;${result}`;
-            }
-            return '';
-        }
-        const content = keyFrameCss + fontFaceCss + staticCss + lowPrioRulesCss + rulesCss + atRulesCss;
-        if (this.options.enableSourceMaps) {
-            return printSourceMap.printSourceMap(this.sourceMapReferences, content);
-        }
-        return content;
-    }
-    serialize() {
-        const { caches , usedIds , identifierCount , sourceMapReferences: sourceMapReferencesData  } = this;
-        const sourceMapReferences = this.options.enableSourceMaps ? sourceMapReferencesData : undefined;
-        return JSON.stringify({
-            caches,
-            usedIds,
-            identifierCount,
-            sourceMapReferences
-        });
-    }
-    async deserialize(buffer) {
-        const data = JSON.parse(buffer.toString());
-        function assign(target, source) {
-            for(const key in source){
-                if (isObject.isObject(target[key]) && isObject.isObject(source[key])) {
-                    assign(target[key], source[key]);
-                } else {
-                    target[key] = source[key];
-                }
-            }
-            return target;
-        }
-        assign(this, data);
-    }
-    setFilePath(filePath) {
-        this.filePath = filePath;
-    }
-    getUsedFilePaths() {
-        return Object.keys(this.usedIds);
-    }
-    getItems(caches) {
-        return Object.keys(caches).reduce((acc, key)=>({
-                ...acc,
-                [key]: this.caches[key].items(caches[key])
-            }), {});
-    }
-    clearUsedIds(filePath) {
-        if (filePath === undefined) {
-            return;
-        }
-        this.usedIds[filePath] = {};
-    }
-    addUsedIds(cacheType, identifiers) {
-        const { filePath  } = this;
-        if (filePath === undefined) {
-            return;
-        }
-        if (this.usedIds[filePath] === undefined) {
-            this.usedIds[filePath] = {};
-        }
-        if (this.usedIds[filePath][cacheType] === undefined) {
-            this.usedIds[filePath][cacheType] = [];
-        }
-        this.usedIds[filePath][cacheType] = [
-            ...new Set([
-                ...this.usedIds[filePath][cacheType],
-                ...identifiers
-            ])
-        ];
-    }
-    getCacheIds(filePaths = []) {
-        return filePaths.reduce((acc, filePath)=>({
-                ...acc,
-                ...Object.keys(this.usedIds[filePath] || []).reduce((cache, key)=>({
-                        ...cache,
-                        [key]: [
-                            ...acc[key] || [],
-                            ...this.usedIds[filePath][key] || []
-                        ]
-                    }), {})
-            }), Object.keys(this.caches).reduce((acc, key)=>({
-                ...acc,
-                [key]: []
-            }), {}));
-    }
-}
-
-exports.ClassList = classList.ClassList;
-exports.Static = _static.Static;
+var Engine = class {
+	caches = {
+		rule: new require_cache.Cache(new require_identifiers_propertyValueIDGenerator.PropertyValueIDGenerator()),
+		static: new require_cache.Cache(new require_identifiers_IDGenerator.IDGenerator()),
+		keyframes: new require_cache.Cache(new require_identifiers_alphaIDGenerator.AlphaIDGenerator()),
+		fontFace: new require_cache.Cache(new require_identifiers_alphaIDGenerator.AlphaIDGenerator()),
+		identifiers: new require_cache.Cache(new require_identifiers_alphaIDGenerator.AlphaIDGenerator())
+	};
+	usedIds = {};
+	filePath;
+	identifierCount = 0;
+	options = {};
+	sourceMapReferences = {};
+	constructor(options = {}) {
+		this.options = {
+			...defaultOptions,
+			...Object.keys(options).reduce((acc, key) => {
+				if (options[key] !== void 0) acc[key] = options[key];
+				return acc;
+			}, {})
+		};
+	}
+	addStatic(selector, styles) {
+		this.addUsedIds("static", require_processStyles.processStyles({
+			type: "static",
+			cache: this.caches.static
+		})({
+			styles,
+			selector
+		}).map((style) => style.id));
+		return new require_wrappers_static.Static();
+	}
+	addStyle(styles) {
+		const ids = require_processStyles.processStyles({
+			type: "rule",
+			cache: this.caches.rule
+		})({ styles }).map((rule) => rule.id);
+		this.addUsedIds("rule", ids);
+		return new require_wrappers_classList.ClassList(ids.join(" "));
+	}
+	addFontFace(fontFace) {
+		const { id } = this.caches.fontFace.getOrStore({
+			type: "fontFace",
+			rule: Array.isArray(fontFace) ? fontFace : [fontFace]
+		});
+		this.addUsedIds("fontFace", [id]);
+		return id;
+	}
+	addKeyframes(keyframes) {
+		const { id } = this.caches.keyframes.getOrStore({
+			type: "keyframes",
+			rule: require_processKeyframes.processKeyframes(keyframes)
+		});
+		this.addUsedIds("keyframes", [id]);
+		return id;
+	}
+	addSourceMapReference({ filePath, identifier, classList, line, column, index }) {
+		if (!this.options.enableSourceMaps) return false;
+		const { name } = node_path.default.parse(filePath);
+		const extraClass = this.options.enableDebugIdentifiers ? `${name}_${identifier}` : "";
+		const selector = "." + classList.toString().split(" ").concat(extraClass).filter(Boolean).join(".");
+		const newFilePath = node_path.default.relative(this.options.context || process.cwd(), filePath);
+		if (index === 0 || !this.sourceMapReferences[newFilePath]) this.sourceMapReferences[newFilePath] = [];
+		this.sourceMapReferences[newFilePath][index] = {
+			selector,
+			line,
+			column
+		};
+		return extraClass;
+	}
+	clearSourceMapReferences(filePath) {
+		const newFilePath = node_path.default.relative(this.options.context || process.cwd(), filePath);
+		this.sourceMapReferences[newFilePath] = [];
+	}
+	clearCache(filePath) {
+		this.clearUsedIds(filePath);
+		this.clearSourceMapReferences(filePath);
+	}
+	generateIdentifier(value) {
+		if (typeof value === "undefined") {
+			let identifier = (0, _emotion_hash.default)((this.identifierCount++).toString(36));
+			if (identifier.match(/^\d/)) identifier = `_${identifier}`;
+			return identifier;
+		}
+		const newValue = JSON.stringify(value);
+		const { id } = this.caches.identifiers.getOrStore({ value: newValue });
+		this.addUsedIds("identifiers", [id]);
+		return `_${id}`;
+	}
+	renderCssToString(options) {
+		const { filePaths, usedIds, opinionatedLayers = false } = options || {};
+		const { keyframes: keyframesCache, fontFace: fontFaceCache, static: staticCache, rule: ruleCache } = usedIds ?? this.getCacheIds(filePaths ?? Object.keys(this.usedIds));
+		const { atRules, lowPrioRules, rules } = require_helpers_splitStyleBlocks.splitStyleBlocks(this.caches.rule.items(ruleCache));
+		const keyFrameCss = require_printers_printKeyFrames.printKeyFrames(this.caches.keyframes.items(keyframesCache));
+		const fontFaceCss = require_printers_printFontFaces.printFontFaces(this.caches.fontFace.items(fontFaceCache));
+		const staticCss = require_printers_printStyleBlocks.printStyleBlocks(this.caches.static.items(staticCache));
+		const atRulesCss = require_printers_printStyleBlocks.printStyleBlocks(require_printers_sortAtRules.sortAtRules(atRules));
+		const lowPrioRulesCss = require_printers_printStyleBlocks.printStyleBlocks(lowPrioRules);
+		const rulesCss = require_printers_printStyleBlocks.printStyleBlocks(rules);
+		if (opinionatedLayers) {
+			const result = `${keyFrameCss}${fontFaceCss}` + (staticCss.length > 0 ? `@layer s{${staticCss}}` : "") + (lowPrioRulesCss.length > 0 ? `@layer lpr{${lowPrioRulesCss}}` : "") + (rulesCss.length > 0 ? `@layer r{${rulesCss}}` : "") + (atRulesCss.length > 0 ? `@layer at{${atRulesCss}}` : "");
+			if (result.length > 0) return `@layer s,lpr,r,at;${result}`;
+			return "";
+		}
+		const content = keyFrameCss + fontFaceCss + staticCss + lowPrioRulesCss + rulesCss + atRulesCss;
+		if (this.options.enableSourceMaps) return require_printers_printSourceMap.printSourceMap(this.sourceMapReferences, content);
+		return content;
+	}
+	serialize() {
+		const { caches, usedIds, identifierCount, sourceMapReferences: sourceMapReferencesData } = this;
+		const sourceMapReferences = this.options.enableSourceMaps ? sourceMapReferencesData : void 0;
+		return JSON.stringify({
+			caches,
+			usedIds,
+			identifierCount,
+			sourceMapReferences
+		});
+	}
+	async deserialize(buffer) {
+		const data = JSON.parse(buffer.toString());
+		function assign(target, source) {
+			for (const key in source) if (require_helpers_isObject.isObject(target[key]) && require_helpers_isObject.isObject(source[key])) assign(target[key], source[key]);
+			else target[key] = source[key];
+			return target;
+		}
+		assign(this, data);
+	}
+	setFilePath(filePath) {
+		this.filePath = filePath;
+	}
+	getUsedFilePaths() {
+		return Object.keys(this.usedIds);
+	}
+	getItems(caches) {
+		const result = {};
+		for (const key of Object.keys(caches)) result[key] = this.caches[key].items(caches[key]);
+		return result;
+	}
+	clearUsedIds(filePath) {
+		if (filePath === void 0) return;
+		this.usedIds[filePath] = {};
+	}
+	addUsedIds(cacheType, identifiers) {
+		const { filePath } = this;
+		if (filePath === void 0) return;
+		if (this.usedIds[filePath] === void 0) this.usedIds[filePath] = {};
+		if (this.usedIds[filePath][cacheType] === void 0) this.usedIds[filePath][cacheType] = [];
+		this.usedIds[filePath][cacheType] = [.../* @__PURE__ */ new Set([...this.usedIds[filePath][cacheType], ...identifiers])];
+	}
+	getCacheIds(filePaths = []) {
+		const result = {};
+		for (const key of Object.keys(this.caches)) result[key] = [];
+		for (const filePath of filePaths) {
+			const used = this.usedIds[filePath];
+			if (!used) continue;
+			for (const key of Object.keys(used)) result[key] = [...result[key] || [], ...used[key] || []];
+		}
+		return result;
+	}
+};
+//#endregion
+exports.ClassList = require_wrappers_classList.ClassList;
 exports.Engine = Engine;
+exports.Static = require_wrappers_static.Static;