@navita/engine 0.0.10 → 0.0.12

package/helpers/isObject.mjs

@@ -0,0 +1,5 @@
+function isObject(val) {
+    return val != null && typeof val === 'object' && Array.isArray(val) === false;
+}
+
+export { isObject };

package/helpers/isSupportsQuery.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function isSupportsQuery(property) {
+    return property.startsWith("@supports");
+}
+
+exports.isSupportsQuery = isSupportsQuery;

package/helpers/isSupportsQuery.mjs

@@ -0,0 +1,5 @@
+function isSupportsQuery(property) {
+    return property.startsWith("@supports");
+}
+
+export { isSupportsQuery };

package/helpers/normalizeCSSVarsProperty.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const regex = /var\(([^,]+).*\)/;
+function normalizeCSSVarsProperty(property) {
+    if (!property.startsWith('var(')) {
+        return property;
+    }
+    const matches = property.match(regex);
+    if (!matches) {
+        return property;
+    }
+    return matches[1];
+}
+
+exports.normalizeCSSVarsProperty = normalizeCSSVarsProperty;

package/helpers/normalizeCSSVarsProperty.mjs

@@ -0,0 +1,13 @@
+const regex = /var\(([^,]+).*\)/;
+function normalizeCSSVarsProperty(property) {
+    if (!property.startsWith('var(')) {
+        return property;
+    }
+    const matches = property.match(regex);
+    if (!matches) {
+        return property;
+    }
+    return matches[1];
+}
+
+export { normalizeCSSVarsProperty };

package/helpers/normalizeNestedProperty.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+function normalizeNestedProperty(nestedProperty) {
+    if (nestedProperty.charAt(0) === '&') {
+        return nestedProperty.slice(1);
+    }
+    return nestedProperty;
+}
+
+exports.normalizeNestedProperty = normalizeNestedProperty;

package/helpers/normalizeNestedProperty.mjs

@@ -0,0 +1,8 @@
+function normalizeNestedProperty(nestedProperty) {
+    if (nestedProperty.charAt(0) === '&') {
+        return nestedProperty.slice(1);
+    }
+    return nestedProperty;
+}
+
+export { normalizeNestedProperty };

package/helpers/pixelifyProperties.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+const UNITLESS = {
+    animationIterationCount: true,
+    borderImage: true,
+    borderImageOutset: true,
+    borderImageSlice: true,
+    borderImageWidth: true,
+    boxFlex: true,
+    boxFlexGroup: true,
+    columnCount: true,
+    columns: true,
+    flex: true,
+    flexGrow: true,
+    flexShrink: true,
+    fontWeight: true,
+    gridArea: true,
+    gridColumn: true,
+    gridColumnEnd: true,
+    gridColumnStart: true,
+    gridRow: true,
+    gridRowEnd: true,
+    gridRowStart: true,
+    initialLetter: true,
+    lineClamp: true,
+    lineHeight: true,
+    maxLines: true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    scale: true,
+    tabSize: true,
+    WebkitLineClamp: true,
+    widows: true,
+    zIndex: true,
+    zoom: true,
+    // svg properties
+    fillOpacity: true,
+    floodOpacity: true,
+    maskBorder: true,
+    maskBorderOutset: true,
+    maskBorderSlice: true,
+    maskBorderWidth: true,
+    shapeImageThreshold: true,
+    stopOpacity: true,
+    strokeDashoffset: true,
+    strokeMiterlimit: true,
+    strokeOpacity: true,
+    strokeWidth: true
+};
+function pixelifyProperties(property, value) {
+    if (value !== 0 && !UNITLESS[property]) {
+        return `${value}px`;
+    }
+    return value;
+}
+
+exports.pixelifyProperties = pixelifyProperties;

package/helpers/pixelifyProperties.mjs

@@ -0,0 +1,56 @@
+const UNITLESS = {
+    animationIterationCount: true,
+    borderImage: true,
+    borderImageOutset: true,
+    borderImageSlice: true,
+    borderImageWidth: true,
+    boxFlex: true,
+    boxFlexGroup: true,
+    columnCount: true,
+    columns: true,
+    flex: true,
+    flexGrow: true,
+    flexShrink: true,
+    fontWeight: true,
+    gridArea: true,
+    gridColumn: true,
+    gridColumnEnd: true,
+    gridColumnStart: true,
+    gridRow: true,
+    gridRowEnd: true,
+    gridRowStart: true,
+    initialLetter: true,
+    lineClamp: true,
+    lineHeight: true,
+    maxLines: true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    scale: true,
+    tabSize: true,
+    WebkitLineClamp: true,
+    widows: true,
+    zIndex: true,
+    zoom: true,
+    // svg properties
+    fillOpacity: true,
+    floodOpacity: true,
+    maskBorder: true,
+    maskBorderOutset: true,
+    maskBorderSlice: true,
+    maskBorderWidth: true,
+    shapeImageThreshold: true,
+    stopOpacity: true,
+    strokeDashoffset: true,
+    strokeMiterlimit: true,
+    strokeOpacity: true,
+    strokeWidth: true
+};
+function pixelifyProperties(property, value) {
+    if (value !== 0 && !UNITLESS[property]) {
+        return `${value}px`;
+    }
+    return value;
+}
+
+export { pixelifyProperties };

package/helpers/splitStyleBlocks.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function splitStyleBlocks(blocks) {
+    const atRules = [];
+    const rules = [];
+    for (const block of blocks){
+        if (block.media || block.support) {
+            atRules.push(block);
+        } else {
+            rules.push(block);
+        }
+    }
+    return {
+        atRules,
+        rules
+    };
+}
+
+exports.splitStyleBlocks = splitStyleBlocks;

package/helpers/splitStyleBlocks.mjs

@@ -0,0 +1,17 @@
+function splitStyleBlocks(blocks) {
+    const atRules = [];
+    const rules = [];
+    for (const block of blocks){
+        if (block.media || block.support) {
+            atRules.push(block);
+        } else {
+            rules.push(block);
+        }
+    }
+    return {
+        atRules,
+        rules
+    };
+}
+
+export { splitStyleBlocks };

package/helpers/transformContentProperty.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+// https://github.com/vanilla-extract-css/vanilla-extract/blob/40d7e72c041989a4dc847dc66b94a4c680b5536e/packages/css/src/transformCss.ts#L277
+function transformContentProperty(value) {
+    return value && (value.includes('"') || value.includes("'") || /^([A-Za-z\-]+\([^]*|[^]*-quote|inherit|initial|none|normal|revert|unset)(\s|$)/.test(value)) ? value : `"${value}"`;
+}
+
+exports.transformContentProperty = transformContentProperty;

package/helpers/transformContentProperty.mjs

@@ -0,0 +1,6 @@
+// https://github.com/vanilla-extract-css/vanilla-extract/blob/40d7e72c041989a4dc847dc66b94a4c680b5536e/packages/css/src/transformCss.ts#L277
+function transformContentProperty(value) {
+    return value && (value.includes('"') || value.includes("'") || /^([A-Za-z\-]+\([^]*|[^]*-quote|inherit|initial|none|normal|revert|unset)(\s|$)/.test(value)) ? value : `"${value}"`;
+}
+
+export { transformContentProperty };

package/identifiers/IDGenerator.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+class IDGenerator {
+    counter = 1;
+    next() {
+        return this.counter++;
+    }
+}
+
+exports.IDGenerator = IDGenerator;

package/identifiers/IDGenerator.mjs

@@ -0,0 +1,8 @@
+class IDGenerator {
+    counter = 1;
+    next() {
+        return this.counter++;
+    }
+}
+
+export { IDGenerator };

package/identifiers/alphaIDGenerator.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+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;
+    }
+}
+
+exports.AlphaIDGenerator = AlphaIDGenerator;

package/identifiers/alphaIDGenerator.mjs

@@ -0,0 +1,25 @@
+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;
+    }
+}
+
+export { AlphaIDGenerator };

package/identifiers/propertyValueIDGenerator.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var identifiers_alphaIDGenerator = require('./alphaIDGenerator.cjs');
+
+class PropertyValueIDGenerator {
+    property = new identifiers_alphaIDGenerator.AlphaIDGenerator();
+    cache = {};
+    next({ property , media ='' , support ='' , pseudo ='' , value  }) {
+        const propertyKey = `${media}${support}${pseudo}${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]}`;
+    }
+}
+
+exports.PropertyValueIDGenerator = PropertyValueIDGenerator;

package/identifiers/propertyValueIDGenerator.mjs

@@ -0,0 +1,22 @@
+import { AlphaIDGenerator } from './alphaIDGenerator.mjs';
+
+class PropertyValueIDGenerator {
+    property = new AlphaIDGenerator();
+    cache = {};
+    next({ property , media ='' , support ='' , pseudo ='' , value  }) {
+        const propertyKey = `${media}${support}${pseudo}${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]}`;
+    }
+}
+
+export { PropertyValueIDGenerator };

package/index.cjs

@@ -0,0 +1,213 @@
+'use strict';
+
+var path = require('node:path');
+var hash = require('@emotion/hash');
+var cache = require('./cache.cjs');
+var helpers_isObject = require('./helpers/isObject.cjs');
+var helpers_splitStyleBlocks = require('./helpers/splitStyleBlocks.cjs');
+var identifiers_IDGenerator = require('./identifiers/IDGenerator.cjs');
+var identifiers_alphaIDGenerator = require('./identifiers/alphaIDGenerator.cjs');
+var identifiers_propertyValueIDGenerator = require('./identifiers/propertyValueIDGenerator.cjs');
+var printers_printFontFaces = require('./printers/printFontFaces.cjs');
+var printers_printKeyFrames = require('./printers/printKeyFrames.cjs');
+var printers_printSourceMap = require('./printers/printSourceMap.cjs');
+var printers_printStyleBlocks = require('./printers/printStyleBlocks.cjs');
+var printers_sortAtRules = require('./printers/sortAtRules.cjs');
+var processStyles = require('./processStyles.cjs');
+var wrappers_classList = require('./wrappers/classList.cjs');
+var wrappers_static = require('./wrappers/static.cjs');
+
+const defaultOptions = {
+    enableSourceMaps: false,
+    enableDebugIdentifiers: false
+};
+class Engine {
+    caches = {
+        rule: new cache.Cache(new identifiers_propertyValueIDGenerator.PropertyValueIDGenerator()),
+        static: new cache.Cache(new identifiers_IDGenerator.IDGenerator()),
+        keyframes: new cache.Cache(new identifiers_alphaIDGenerator.AlphaIDGenerator()),
+        fontFace: new cache.Cache(new identifiers_alphaIDGenerator.AlphaIDGenerator()),
+        identifiers: new cache.Cache(new identifiers_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 wrappers_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 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: 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;
+    }
+    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.getUsedCacheIds(filePaths ?? Object.keys(this.usedIds));
+        const { atRules , rules  } = helpers_splitStyleBlocks.splitStyleBlocks(this.caches.rule.items(ruleCache));
+        const keyFrameCss = printers_printKeyFrames.printKeyFrames(this.caches.keyframes.items(keyframesCache));
+        const fontFaceCss = printers_printFontFaces.printFontFaces(this.caches.fontFace.items(fontFaceCache));
+        const staticCss = printers_printStyleBlocks.printStyleBlocks(this.caches.static.items(staticCache));
+        const atRulesCss = printers_printStyleBlocks.printStyleBlocks(printers_sortAtRules.sortAtRules(atRules));
+        const rulesCss = printers_printStyleBlocks.printStyleBlocks(rules);
+        if (opinionatedLayers) {
+            const result = `${keyFrameCss}${fontFaceCss}` + (staticCss.length > 0 ? `@layer static{${staticCss}}` : '') + (rulesCss.length > 0 ? `@layer rules{${rulesCss}}` : '') + (atRulesCss.length > 0 ? `@layer at{${atRulesCss}}` : '');
+            if (result.length > 0) {
+                return `@layer static,rules,at;${result}`;
+            }
+            return '';
+        }
+        return printers_printSourceMap.printSourceMap(this.sourceMapReferences, keyFrameCss + fontFaceCss + staticCss + rulesCss + atRulesCss);
+    }
+    serialize() {
+        const { caches , usedIds , identifierCount , sourceMapReferences  } = this;
+        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 (helpers_isObject.isObject(target[key]) && 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;
+    }
+    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
+            ])
+        ];
+    }
+    getUsedCacheIds(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 = wrappers_classList.ClassList;
+exports.Static = wrappers_static.Static;
+exports.Engine = Engine;