@navita/engine 0.2.2 → 3.0.0-next.1

package/index.d.ts

@@ -1,98 +1,105 @@
-import { CSSKeyframes, FontFaceRule, StyleRule } from '@navita/types';
+import { CSSKeyframes, FontFaceRule, StyleRule } from "@navita/types";
 
+//#region src/types.d.ts
 interface StyleBlock {
-    type: 'rule' | 'static';
-    selector: string;
-    property: string;
-    value: string;
-    pseudo: string;
-    media: string;
-    support: string;
-    container: string;
-    id: string | number;
+  type: "rule" | "static";
+  selector: string;
+  property: string;
+  value: string;
+  pseudo: string;
+  media: string;
+  support: string;
+  container: string;
+  id: string | number;
 }
 interface KeyframesBlock {
-    type: 'keyframes';
-    rule: CSSKeyframes;
-    id: string;
+  type: "keyframes";
+  rule: CSSKeyframes;
+  id: string;
 }
 interface FontFaceBlock {
-    type: 'fontFace';
-    rule: FontFaceRule[];
-    id: string;
+  type: "fontFace";
+  rule: FontFaceRule[];
+  id: string;
 }
-
-declare class ClassList extends String {
-}
-
-declare class Static {
-}
-
+//#endregion
+//#region src/wrappers/classList.d.ts
+declare class ClassList extends String {}
+//#endregion
+//#region src/wrappers/static.d.ts
+declare class Static {}
+//#endregion
+//#region src/index.d.ts
 type CacheKeys = keyof Engine["caches"];
-type UsedIdCache = {
-    [key in CacheKeys]?: (string | number)[];
-};
+type UsedIdCache = { [key in CacheKeys]?: (string | number)[] };
 interface Identifier {
-    value: string;
-    id: string;
+  value: string;
+  id: string;
 }
 type Options = {
-    context?: string;
-    enableSourceMaps?: boolean;
-    enableDebugIdentifiers?: boolean;
+  context?: string;
+  enableSourceMaps?: boolean;
+  enableDebugIdentifiers?: boolean;
 };
 declare class Engine {
-    private readonly caches;
-    private readonly usedIds;
-    private filePath;
-    private identifierCount;
-    private readonly options;
-    private sourceMapReferences;
-    constructor(options?: Options);
-    addStatic(selector: string, styles: StyleRule): Static;
-    addStyle(styles: StyleRule): ClassList;
-    addFontFace(fontFace: FontFaceRule | FontFaceRule[]): string;
-    addKeyframes(keyframes: CSSKeyframes): string;
-    addSourceMapReference({ filePath, identifier, classList, line, column, index }: {
-        index: number;
-        identifier: string;
-        classList: ClassList;
-        filePath: string;
-        line: number;
-        column: number;
-    }): string | false;
-    private clearSourceMapReferences;
-    clearCache(filePath: string): void;
-    generateIdentifier(value: unknown): string;
-    renderCssToString(options?: {
-        filePaths?: string[];
-        usedIds?: UsedIdCache;
-        opinionatedLayers?: boolean;
-    }): string;
-    serialize(): string;
-    deserialize(buffer: Buffer | string): Promise<void>;
-    setFilePath(filePath: string | undefined): void;
-    getUsedFilePaths(): string[];
-    getItems(caches: UsedIdCache): {
-        rule?: (StyleBlock & {
-            id: string | number;
-        })[];
-        static?: (StyleBlock & {
-            id: string | number;
-        })[];
-        keyframes?: (KeyframesBlock & {
-            id: string | number;
-        })[];
-        fontFace?: (FontFaceBlock & {
-            id: string | number;
-        })[];
-        identifiers?: (Identifier & {
-            id: string | number;
-        })[];
-    };
-    clearUsedIds(filePath: string): void;
-    private addUsedIds;
-    getCacheIds(filePaths?: string[]): UsedIdCache;
+  private readonly caches;
+  private readonly usedIds;
+  private filePath;
+  private identifierCount;
+  private readonly options;
+  private sourceMapReferences;
+  constructor(options?: Options);
+  addStatic(selector: string, styles: StyleRule): Static;
+  addStyle(styles: StyleRule): ClassList;
+  addFontFace(fontFace: FontFaceRule | FontFaceRule[]): string;
+  addKeyframes(keyframes: CSSKeyframes): string;
+  addSourceMapReference({
+    filePath,
+    identifier,
+    classList,
+    line,
+    column,
+    index
+  }: {
+    index: number;
+    identifier: string;
+    classList: ClassList;
+    filePath: string;
+    line: number;
+    column: number;
+  }): string | false;
+  private clearSourceMapReferences;
+  clearCache(filePath: string): void;
+  generateIdentifier(value: unknown): string;
+  renderCssToString(options?: {
+    filePaths?: string[];
+    usedIds?: UsedIdCache;
+    opinionatedLayers?: boolean;
+  }): string;
+  serialize(): string;
+  deserialize(buffer: Buffer | string): Promise<void>;
+  setFilePath(filePath: string | undefined): void;
+  getUsedFilePaths(): string[];
+  getItems(caches: UsedIdCache): {
+    rule?: (StyleBlock & {
+      id: string | number;
+    })[];
+    static?: (StyleBlock & {
+      id: string | number;
+    })[];
+    keyframes?: (KeyframesBlock & {
+      id: string | number;
+    })[];
+    fontFace?: (FontFaceBlock & {
+      id: string | number;
+    })[];
+    identifiers?: (Identifier & {
+      id: string | number;
+    })[];
+  };
+  clearUsedIds(filePath: string): void;
+  private addUsedIds;
+  getCacheIds(filePaths?: string[]): UsedIdCache;
 }
-
-export { ClassList, Engine, Options, Static, UsedIdCache };
+//#endregion
+export { ClassList, Engine, Options, Static, UsedIdCache };

package/index.mjs

@@ -1,237 +1,187 @@
-import path from 'node:path';
-import hash from '@emotion/hash';
-import { Cache } from './cache.mjs';
-import { isObject } from './helpers/isObject.mjs';
-import { splitStyleBlocks } from './helpers/splitStyleBlocks.mjs';
-import { IDGenerator } from './identifiers/IDGenerator.mjs';
-import { AlphaIDGenerator } from './identifiers/alphaIDGenerator.mjs';
-import { PropertyValueIDGenerator } from './identifiers/propertyValueIDGenerator.mjs';
-import { printFontFaces } from './printers/printFontFaces.mjs';
-import { printKeyFrames } from './printers/printKeyFrames.mjs';
-import { printSourceMap } from './printers/printSourceMap.mjs';
-import { printStyleBlocks } from './printers/printStyleBlocks.mjs';
-import { sortAtRules } from './printers/sortAtRules.mjs';
-import { processKeyframes } from './processKeyframes.mjs';
-import { processStyles } from './processStyles.mjs';
-import { ClassList } from './wrappers/classList.mjs';
-import { Static } from './wrappers/static.mjs';
-
+import "node:path";
+import "node:url";
+import.meta.url;
+import { Cache } from "./cache.mjs";
+import { isObject } from "./helpers/isObject.mjs";
+import { splitStyleBlocks } from "./helpers/splitStyleBlocks.mjs";
+import { AlphaIDGenerator } from "./identifiers/alphaIDGenerator.mjs";
+import { IDGenerator } from "./identifiers/IDGenerator.mjs";
+import { PropertyValueIDGenerator } from "./identifiers/propertyValueIDGenerator.mjs";
+import { printFontFaces } from "./printers/printFontFaces.mjs";
+import { printKeyFrames } from "./printers/printKeyFrames.mjs";
+import { printSourceMap } from "./printers/printSourceMap.mjs";
+import { printStyleBlocks } from "./printers/printStyleBlocks.mjs";
+import { sortAtRules } from "./printers/sortAtRules.mjs";
+import { processKeyframes } from "./processKeyframes.mjs";
+import { processStyles } from "./processStyles.mjs";
+import { ClassList } from "./wrappers/classList.mjs";
+import { Static } from "./wrappers/static.mjs";
+import path from "node:path";
+import hash from "@emotion/hash";
+//#region src/index.ts
 const defaultOptions = {
-    enableSourceMaps: false,
-    enableDebugIdentifiers: false
+	enableSourceMaps: false,
+	enableDebugIdentifiers: false
 };
-class Engine {
-    caches = {
-        rule: new Cache(new PropertyValueIDGenerator()),
-        static: new Cache(new IDGenerator()),
-        keyframes: new Cache(new AlphaIDGenerator()),
-        fontFace: new Cache(new AlphaIDGenerator()),
-        identifiers: new Cache(new 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({
-            type: "static",
-            cache: this.caches.static
-        })({
-            styles,
-            selector
-        }).map((style)=>style.id));
-        return new Static();
-    }
-    addStyle(styles) {
-        const rules = processStyles({
-            type: "rule",
-            cache: this.caches.rule
-        })({
-            styles
-        });
-        const ids = rules.map((rule)=>rule.id);
-        this.addUsedIds("rule", ids);
-        return new 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(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(this.caches.rule.items(ruleCache));
-        const keyFrameCss = printKeyFrames(this.caches.keyframes.items(keyframesCache));
-        const fontFaceCss = printFontFaces(this.caches.fontFace.items(fontFaceCache));
-        const staticCss = printStyleBlocks(this.caches.static.items(staticCache));
-        const atRulesCss = printStyleBlocks(sortAtRules(atRules));
-        const lowPrioRulesCss = printStyleBlocks(lowPrioRules);
-        const rulesCss = 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(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(target[key]) && 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]: []
-            }), {}));
-    }
-}
-
+var Engine = class {
+	caches = {
+		rule: new Cache(new PropertyValueIDGenerator()),
+		static: new Cache(new IDGenerator()),
+		keyframes: new Cache(new AlphaIDGenerator()),
+		fontFace: new Cache(new AlphaIDGenerator()),
+		identifiers: new Cache(new 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", processStyles({
+			type: "static",
+			cache: this.caches.static
+		})({
+			styles,
+			selector
+		}).map((style) => style.id));
+		return new Static();
+	}
+	addStyle(styles) {
+		const ids = processStyles({
+			type: "rule",
+			cache: this.caches.rule
+		})({ styles }).map((rule) => rule.id);
+		this.addUsedIds("rule", ids);
+		return new 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(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 || {};
+		const { keyframes: keyframesCache, fontFace: fontFaceCache, static: staticCache, rule: ruleCache } = usedIds ?? this.getCacheIds(filePaths ?? Object.keys(this.usedIds));
+		const { atRules, lowPrioRules, rules } = splitStyleBlocks(this.caches.rule.items(ruleCache));
+		const keyFrameCss = printKeyFrames(this.caches.keyframes.items(keyframesCache));
+		const fontFaceCss = printFontFaces(this.caches.fontFace.items(fontFaceCache));
+		const staticCss = printStyleBlocks(this.caches.static.items(staticCache));
+		const atRulesCss = printStyleBlocks(sortAtRules(atRules));
+		const lowPrioRulesCss = printStyleBlocks(lowPrioRules);
+		const rulesCss = 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 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 (isObject(target[key]) && 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
 export { ClassList, Engine, Static };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navita/engine",
-  "version": "0.2.2",
+  "version": "3.0.0-next.1",
   "description": "Navitas CSS-in-JS engine",
   "keywords": [
     "css-in-js",

package/printers/printFontFaces.cjs

@@ -1,15 +1,10 @@
-'use strict';
-
-var declarationsToBlock = require('../helpers/declarationsToBlock.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_helpers_declarationsToBlock = require("../helpers/declarationsToBlock.cjs");
+//#region src/printers/printFontFaces.ts
 function printFontFaces(blocks) {
-    let fontFaces = '';
-    for (const block of blocks){
-        for (const rule of block.rule){
-            fontFaces += `@font-face{font-family:${block.id};${declarationsToBlock.declarationsToBlock(rule)}}`;
-        }
-    }
-    return fontFaces;
+	let fontFaces = "";
+	for (const block of blocks) for (const rule of block.rule) fontFaces += `@font-face{font-family:${block.id};${require_helpers_declarationsToBlock.declarationsToBlock(rule)}}`;
+	return fontFaces;
 }
-
+//#endregion
 exports.printFontFaces = printFontFaces;