@master/css-runtime 2.0.0-rc.5 → 2.0.0-rc.51

package/dist/index.cjs

@@ -0,0 +1,439 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var css = require('@master/css');
+
+class RuntimeCSS extends css.MasterCSS {
+    root;
+    customConfig;
+    // @ts-expect-error
+    host;
+    observing;
+    progressive;
+    // @ts-expect-error
+    container;
+    observer;
+    constructor(root = document, customConfig = css.config){
+        super(customConfig), this.root = root, this.customConfig = customConfig, this.observing = false, this.progressive = false;
+        this.init();
+    }
+    init() {
+        const existingRuntimeCSS = globalThis.runtimeCSSs.find((eachCSS)=>eachCSS.root === this.root);
+        if (existingRuntimeCSS) throw new Error('Cannot create multiple RuntimeCSS instances for the same root element.');
+        const rootConstructorName = this.root?.constructor.name;
+        if (rootConstructorName === 'HTMLDocument' || rootConstructorName === 'Document') {
+            // @ts-ignore
+            this.root.defaultView.globalThis.runtimeCSS = this;
+            // @ts-ignore readonly
+            this.container = this.root.head;
+            // @ts-ignore readonly
+            this.host = this.root.documentElement;
+        } else {
+            // @ts-ignore readonly
+            this.container = this.root;
+            // @ts-ignore readonly
+            this.host = this.root.host;
+        }
+        runtimeCSSs.push(this);
+    }
+    /**
+     * Observe the DOM for changes and update the running stylesheet. (browser only)
+     * @param options mutation observer options
+     * @returns this
+     */ observe() {
+        if (this.observing) return this;
+        if (this.root.styleSheets) for (const sheet of this.root.styleSheets){
+            const { ownerNode } = sheet;
+            if (ownerNode && ownerNode.id === 'master') {
+                this.style = ownerNode;
+                // @ts-ignore
+                this.progressive = true;
+                break;
+            }
+        }
+        if (this.progressive) {
+            this.hydrate(this.style.sheet.cssRules);
+        } else {
+            this.style = document.createElement('style');
+            this.style.id = 'master';
+            this.container.append(this.style);
+            this.style.sheet.insertRule(this.layerStatementRule.text);
+            this.layerStatementRule.nodes[0].native = this.style.sheet.cssRules.item(0);
+        }
+        const firstConnectedElementsClasses = new Map();
+        const addClasses = (element)=>{
+            element.classList.forEach((className)=>{
+                if (this.classUsages.has(className)) {
+                    this.classUsages.set(className, this.classUsages.get(className) + 1);
+                } else {
+                    this.classUsages.set(className, 1);
+                    this.add(className);
+                }
+                const classes = firstConnectedElementsClasses.get(element);
+                if (classes) {
+                    classes.push(className);
+                } else {
+                    firstConnectedElementsClasses.set(element, [
+                        className
+                    ]);
+                }
+            });
+        };
+        addClasses(this.host);
+        /**
+         * 待所有 DOM 結構完成解析後，開始繪製 Rule 樣式
+         */ (this.root.constructor.name === 'HTMLDocument' ? this.host : this.container).querySelectorAll('[class]').forEach((element)=>{
+            addClasses(element);
+        });
+        // @ts-expect-error readonly
+        this.observer = new MutationObserver((mutationRecords)=>{
+            // console.clear()
+            // const test = ''
+            // if (test) {
+            //     console.log('')
+            //     console.log(`${test}: ${this.classUsages.get(test)}`)
+            // }
+            const eachClassUsages = new Map();
+            const targetFirstAttrMutationRecord = new Map();
+            const updateClassUsage = (classes, isAdding = false)=>{
+                const usage = isAdding ? 1 : -1;
+                classes.forEach((className)=>{
+                    eachClassUsages.set(className, (eachClassUsages.get(className) || 0) + usage);
+                });
+            };
+            const connectedStatusMap = new Map();
+            const disconnectedStatusMap = new Map();
+            const recordStatus = (target, mutationRecord, map, adding)=>{
+                const status = map.get(target);
+                if (status) {
+                    status.change += adding ? 1 : -1;
+                    status.mutationRecord = mutationRecord;
+                } else {
+                    map.set(target, {
+                        change: adding ? 1 : -1,
+                        mutationRecord
+                    });
+                }
+            };
+            mutationRecords.forEach((mutationRecord)=>{
+                const target = mutationRecord.target;
+                switch(mutationRecord.type){
+                    case 'attributes':
+                        if (!targetFirstAttrMutationRecord.has(target)) {
+                            targetFirstAttrMutationRecord.set(target, mutationRecord);
+                        }
+                        break;
+                    case 'childList':
+                        const targetStatusMap = target.isConnected ? connectedStatusMap : disconnectedStatusMap;
+                        mutationRecord.addedNodes.forEach((node)=>'classList' in node && recordStatus(node, mutationRecord, targetStatusMap, true));
+                        mutationRecord.removedNodes.forEach((node)=>'classList' in node && recordStatus(node, mutationRecord, targetStatusMap, false));
+                        break;
+                }
+            });
+            const updatedTargetChangeMap = new Map();
+            const updateTarget = (target, adding)=>{
+                const change = updatedTargetChangeMap.get(target) || 0;
+                const newChange = change + (adding ? 1 : -1);
+                if (newChange >= -1 && newChange <= 1) {
+                    updatedTargetChangeMap.set(target, newChange);
+                    const firstAttrMutationRecord = targetFirstAttrMutationRecord.get(target);
+                    if (firstAttrMutationRecord) {
+                        targetFirstAttrMutationRecord.delete(target);
+                    }
+                    if (adding) {
+                        updateClassUsage(target.classList, adding);
+                    } else {
+                        if (firstAttrMutationRecord) {
+                            updateClassUsage(firstAttrMutationRecord.oldValue ? firstAttrMutationRecord.oldValue.split(/\s+/) : [], adding);
+                        } else {
+                            updateClassUsage(target.classList, adding);
+                        }
+                        disconnectedStatusMap.forEach((disconnectedTargetStatus, disconnectedTarget)=>{
+                            if (disconnectedTargetStatus.mutationRecord.target === target && disconnectedTargetStatus.change !== 0) {
+                                updateTarget(disconnectedTarget, disconnectedTargetStatus.change > 0);
+                            }
+                        });
+                    }
+                    for (const child of target.children){
+                        updateTarget(child, adding);
+                    }
+                }
+            };
+            connectedStatusMap.forEach(({ change }, target)=>change !== 0 && updateTarget(target, change > 0));
+            targetFirstAttrMutationRecord.forEach((mutation, target)=>{
+                if (!target.isConnected) return;
+                const oldClassList = mutation.oldValue ? mutation.oldValue.split(/\s+/) : [];
+                const newClassList = target.classList;
+                const addedClasses = [];
+                newClassList.forEach((c)=>{
+                    if (!oldClassList.includes(c)) addedClasses.push(c);
+                });
+                const removedClasses = oldClassList.filter((c)=>!newClassList.contains(c));
+                if (addedClasses.length) {
+                    // console.log('[attribute]', '[add]   ', addedClasses, target)
+                    updateClassUsage(addedClasses, true);
+                }
+                if (removedClasses.length) {
+                    // console.log('[attribute]', '[remove]', removedClasses, target)
+                    updateClassUsage(removedClasses, false);
+                }
+            });
+            /**
+             * Merge the class usage changes into the current class usage map.
+             */ eachClassUsages.forEach((countChange, className)=>{
+                let currentCount = this.classUsages.get(className) || 0;
+                let newCount = currentCount + countChange;
+                if (newCount > 0) {
+                    this.classUsages.set(className, newCount);
+                    if (currentCount === 0) {
+                        this.add(className);
+                    }
+                } else {
+                    this.classUsages.delete(className);
+                    this.remove(className);
+                }
+            });
+        // start: debug
+        // const safeClassUsages: any = {};
+        // ((this.root.constructor.name === 'HTMLDocument') ? this.host : this.container)
+        //     .querySelectorAll('[class]')
+        //     .forEach((element) => {
+        //         element.classList.forEach((className) => {
+        //             if (Object.prototype.hasOwnProperty.call(safeClassUsages, className)) {
+        //                 safeClassUsages[className]++
+        //             } else {
+        //                 safeClassUsages[className] = 1
+        //             }
+        //         })
+        //     })
+        // this.host.classList.forEach((className) => {
+        //     if (Object.prototype.hasOwnProperty.call(safeClassUsages, className)) {
+        //         safeClassUsages[className]++
+        //     } else {
+        //         safeClassUsages[className] = 1
+        //     }
+        // })
+        // for (const className in safeClassUsages) {
+        //     if (this.classUsages.get(className) !== safeClassUsages[className]) {
+        //         throw new Error(`[css] ${className} ${this.classUsages.get(className)} (correct: ${safeClassUsages[className]})`)
+        //     }
+        // }
+        // this.classUsages.forEach((count, className) => {
+        //     if (!Object.prototype.hasOwnProperty.call(safeClassUsages, className)) {
+        //         throw new Error(`[css] ${className} ${count} (correct: 0)`)
+        //     }
+        // })
+        // end: debug
+        });
+        this.observer.observe(this.root, {
+            attributes: true,
+            attributeOldValue: true,
+            attributeFilter: [
+                'class'
+            ],
+            childList: true,
+            subtree: true
+        });
+        if (!this.progressive) {
+            this.host.style.removeProperty('display');
+        }
+        // @ts-ignore
+        this.observing = true;
+        return this;
+    }
+    hydrate(nativeCSSRules) {
+        const cssSyntaxLayerBlockRules = [];
+        for(let i = 0; i < nativeCSSRules.length; i++){
+            const eachNativeCSSRule = nativeCSSRules[i];
+            if (eachNativeCSSRule.constructor.name === 'CSSLayerBlockRule') {
+                const cssLayerBlockRule = eachNativeCSSRule;
+                if (eachNativeCSSRule.name === 'theme') {
+                    this.themeLayer.native = cssLayerBlockRule;
+                    let variableRule;
+                    let lastVariableName;
+                    for(let j = 0; j < cssLayerBlockRule.cssRules.length; j++){
+                        const cssRule = cssLayerBlockRule.cssRules[j];
+                        const variableCSSRule = cssRule.constructor.name === 'CSSMediaRule' ? cssRule.cssRules[0] : cssRule;
+                        const variableName = variableCSSRule.style[0].slice(2);
+                        if (variableName !== lastVariableName) {
+                            lastVariableName = variableName;
+                            variableRule = new css.Rule(variableName);
+                            this.themeLayer.rules.push(variableRule);
+                            this.themeLayer.usages[variableRule.name] = 0;
+                        }
+                        variableRule?.nodes.push({
+                            native: cssRule,
+                            text: cssRule.cssText
+                        });
+                    }
+                    if (this.themeLayer.rules.length) this.rules.push(this.themeLayer);
+                } else {
+                    cssSyntaxLayerBlockRules.push(cssLayerBlockRule);
+                }
+            } else if (eachNativeCSSRule.constructor.name === 'CSSLayerStatementRule') {
+                this.layerStatementRule.nodes[0].native = eachNativeCSSRule;
+            } else if (eachNativeCSSRule.constructor.name === 'CSSKeyframesRule') {
+                const keyframsRule = eachNativeCSSRule;
+                const animationRule = new css.Rule(keyframsRule.name, [
+                    {
+                        native: keyframsRule,
+                        text: keyframsRule.cssText
+                    }
+                ]);
+                this.animationsNonLayer.rules.push(animationRule);
+                this.rules.push(animationRule);
+                this.animationsNonLayer.usages[animationRule.name] = 0;
+            }
+        }
+        for (const cssLayerBlockRule of cssSyntaxLayerBlockRules){
+            const handleSyntaxLayer = (layer)=>{
+                layer.native = cssLayerBlockRule;
+                for(let j = 0; j < cssLayerBlockRule.cssRules.length; j++){
+                    const cssRule = cssLayerBlockRule.cssRules[j];
+                    const createSyntaxRule = (cssRule)=>{
+                        if (cssRule.selectorText) {
+                            const syntaxRule = this.createFromSelectorText(cssRule.selectorText)[0];
+                            if (syntaxRule) return syntaxRule;
+                        } else if (cssRule.cssRules) {
+                            for (const eachCSSRule of cssRule.cssRules){
+                                const syntaxRule = createSyntaxRule(eachCSSRule);
+                                if (syntaxRule) return syntaxRule;
+                            }
+                        }
+                    };
+                    const syntaxRule = createSyntaxRule(cssRule);
+                    if (syntaxRule) {
+                        layer.rules.push(syntaxRule);
+                        layer.insertVariables(syntaxRule);
+                        layer.insertAnimations(syntaxRule);
+                        for (const eachNode of syntaxRule.nodes){
+                            if (!eachNode.native) eachNode.native = cssRule;
+                        }
+                    } else {
+                        cssLayerBlockRule.deleteRule?.(j--);
+                        console.error(`Cannot recognize the CSS rule in the ${layer.name} layer. \`${cssRule.cssText}\` (https://rc.css.master.co/messages/hydration-errors)`);
+                    }
+                }
+                for (const eachRule of layer.rules){
+                    for(let k = eachRule.nodes.length - 1; k >= 0; k--){
+                        if (!eachRule.nodes[k].native) {
+                            eachRule.nodes.splice(k, 1);
+                        }
+                    }
+                }
+                if (layer.rules.length) this.rules.push(layer);
+            };
+            switch(cssLayerBlockRule.name){
+                case 'base':
+                    handleSyntaxLayer(this.baseLayer);
+                    break;
+                case 'preset':
+                    handleSyntaxLayer(this.presetLayer);
+                    break;
+                case 'components':
+                    this.componentsLayer.native = cssLayerBlockRule;
+                    let stylePreText;
+                    const createSyntaxRules = (cssRule)=>{
+                        if (cssRule.selectorText) {
+                            const syntaxRules = this.createFromSelectorText(cssRule.selectorText);
+                            if (syntaxRules.length) {
+                                stylePreText = cssRule.selectorText + '{';
+                                return syntaxRules;
+                            }
+                        } else if (cssRule.cssRules) {
+                            for (const eachCSSRule of cssRule.cssRules){
+                                const syntaxRules = this.createFromSelectorText(eachCSSRule.selectorText);
+                                if (syntaxRules) return syntaxRules;
+                            }
+                        }
+                    };
+                    for(let j = 0; j < cssLayerBlockRule.cssRules.length; j++){
+                        const cssRule = cssLayerBlockRule.cssRules[j];
+                        const syntaxRules = createSyntaxRules(cssRule);
+                        if (syntaxRules) {
+                            let matched = false;
+                            for (const eachSyntaxRule of syntaxRules){
+                                for (const node of eachSyntaxRule.nodes){
+                                    if (!node.native && node.text.includes(stylePreText)) {
+                                        node.native = cssRule;
+                                        if (!this.componentsLayer.rules.includes(eachSyntaxRule)) {
+                                            this.componentsLayer.rules.push(eachSyntaxRule);
+                                            this.componentsLayer.insertVariables(eachSyntaxRule);
+                                            this.componentsLayer.insertAnimations(eachSyntaxRule);
+                                        }
+                                        matched = true;
+                                        break;
+                                    }
+                                }
+                                if (matched) break;
+                            }
+                        } else {
+                            cssLayerBlockRule?.deleteRule?.(j--);
+                            console.error(`Cannot recognize the CSS rule in the components layer. \`${cssRule.cssText}\` (https://rc.css.master.co/messages/hydration-errors)`);
+                        }
+                    }
+                    for (const eachRule of this.componentsLayer.rules){
+                        for(let k = eachRule.nodes.length - 1; k >= 0; k--){
+                            if (!eachRule.nodes[k].native) {
+                                eachRule.nodes.splice(k, 1);
+                            }
+                        }
+                    }
+                    if (this.componentsLayer.rules.length) this.rules.push(this.componentsLayer);
+                    break;
+                case 'general':
+                    handleSyntaxLayer(this.generalLayer);
+                    break;
+            }
+        }
+    }
+    disconnect() {
+        if (!this.observing) return;
+        if (this.observer) {
+            this.observer.disconnect();
+            // @ts-expect-error readonly
+            this.observer = undefined;
+        }
+        // @ts-ignore
+        this.observing = false;
+        this.reset();
+        this.classUsages.clear();
+        if (!this.progressive) {
+            this.style?.remove();
+            this.style = null;
+        }
+        return this;
+    }
+    refresh(customConfig = this.customConfig) {
+        if (!this.observing || !this.style.sheet) return this;
+        for(let i = 1; i <= this.style.sheet.cssRules.length - 1; i++){
+            this.style.sheet.deleteRule(i);
+        }
+        super.refresh(customConfig);
+        return this;
+    }
+    destroy() {
+        this.disconnect();
+        runtimeCSSs.splice(runtimeCSSs.indexOf(this), 1);
+        return this;
+    }
+}
+const runtimeCSSs = [];
+(()=>{
+    globalThis.RuntimeCSS = RuntimeCSS;
+    globalThis.runtimeCSSs = runtimeCSSs;
+})();
+
+/**
+ * Initialize a new RuntimeCSS instance and observe the target root
+ * @param config master css config
+ * @param targetRoot target root to observe
+ * @returns master css instance
+ */ function initCSSRuntime(config) {
+    return new RuntimeCSS(document, config).observe();
+}
+
+exports.RuntimeCSS = RuntimeCSS;
+exports.default = RuntimeCSS;
+exports.initCSSRuntime = initCSSRuntime;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { CSSRuntime, CSSRuntime as default } from './core';
+export { RuntimeCSS, RuntimeCSS as default } from './core';
 export { default as initCSSRuntime } from './init-css-runtime';