@node-projects/web-component-designer 0.0.216 → 0.0.218

package/dist/elements/services/stylesheetService/CssTreeStylesheetService.d.ts

@@ -1,56 +1,56 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IStyleDeclaration, IStyleRule, IStylesheet } from "./IStylesheetService.js";
-import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
-import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
-declare namespace csstree {
-    type CssNodePlain = any;
-    type CssNode = any;
-    type ParseOptions = any;
-    type GenerateOptions = any;
-    type RulePlain = any;
-    type DeclarationPlain = any;
-    type StyleSheetPlain = any;
-    type Raw = any;
-    type Declaration = any;
-    type AtrulePlain = any;
-    type BlockPlain = any;
-    type SelectorListPlain = any;
-}
-declare global {
-    interface Window {
-        csstree: {
-            fromPlainObject(node: csstree.CssNodePlain): csstree.CssNode;
-            toPlainObject(node: csstree.CssNode): csstree.CssNodePlain;
-            parse(text: string, options?: csstree.ParseOptions): csstree.CssNode;
-            generate(ast: csstree.CssNode, options?: csstree.GenerateOptions): string;
-        };
-    }
-}
-interface IRuleWithAST extends IStyleRule {
-    ast: csstree.RulePlain;
-    declarations: IDeclarationWithAST[];
-    stylesheet: IStylesheet;
-}
-interface IDeclarationWithAST extends IStyleDeclaration {
-    ast: csstree.DeclarationPlain;
-}
-export declare class CssTreeStylesheetService extends AbstractStylesheetService {
-    constructor(designerCanvas: IDesignerCanvas);
-    internalParse(style: string): Promise<any>;
-    private getAppliedRulesInternal;
-    getAppliedRules(designItem: IDesignItem): IRuleWithAST[];
-    private getDeclarationInternal;
-    getDeclarations(designItem: IDesignItem, stlyeName: string): IDeclarationWithAST[];
-    updateDeclarationValueWithoutUndo(declaration: IDeclarationWithAST, value: string, important: boolean): void;
-    insertDeclarationIntoRule(rule: IRuleWithAST, property: string, value: string, important: boolean): boolean;
-    removeDeclarationFromRule(rule: IRuleWithAST, property: string): boolean;
-    updateCompleteStylesheet(name: string, newStyle: string): void;
-    private rulesFromAST;
-    private astHasChildren;
-    private buildSelectorString;
-    private getSpecificity;
-    private findDeclarationInRule;
-    private buildAtRuleString;
-    private sortDeclarations;
-}
-export {};
+import { IDesignItem } from "../../item/IDesignItem.js";
+import { IStyleDeclaration, IStyleRule, IStylesheet } from "./IStylesheetService.js";
+import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
+import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
+declare namespace csstree {
+    type CssNodePlain = any;
+    type CssNode = any;
+    type ParseOptions = any;
+    type GenerateOptions = any;
+    type RulePlain = any;
+    type DeclarationPlain = any;
+    type StyleSheetPlain = any;
+    type Raw = any;
+    type Declaration = any;
+    type AtrulePlain = any;
+    type BlockPlain = any;
+    type SelectorListPlain = any;
+}
+declare global {
+    interface Window {
+        csstree: {
+            fromPlainObject(node: csstree.CssNodePlain): csstree.CssNode;
+            toPlainObject(node: csstree.CssNode): csstree.CssNodePlain;
+            parse(text: string, options?: csstree.ParseOptions): csstree.CssNode;
+            generate(ast: csstree.CssNode, options?: csstree.GenerateOptions): string;
+        };
+    }
+}
+interface IRuleWithAST extends IStyleRule {
+    ast: csstree.RulePlain;
+    declarations: IDeclarationWithAST[];
+    stylesheet: IStylesheet;
+}
+interface IDeclarationWithAST extends IStyleDeclaration {
+    ast: csstree.DeclarationPlain;
+}
+export declare class CssTreeStylesheetService extends AbstractStylesheetService {
+    constructor(designerCanvas: IDesignerCanvas);
+    internalParse(style: string): Promise<any>;
+    private getAppliedRulesInternal;
+    getAppliedRules(designItem: IDesignItem): IRuleWithAST[];
+    private getDeclarationInternal;
+    getDeclarations(designItem: IDesignItem, stlyeName: string): IDeclarationWithAST[];
+    updateDeclarationValueWithoutUndo(declaration: IDeclarationWithAST, value: string, important: boolean): void;
+    insertDeclarationIntoRule(rule: IRuleWithAST, property: string, value: string, important: boolean): boolean;
+    removeDeclarationFromRule(rule: IRuleWithAST, property: string): boolean;
+    updateCompleteStylesheet(name: string, newStyle: string): void;
+    private rulesFromAST;
+    private astHasChildren;
+    private buildSelectorString;
+    private getSpecificity;
+    private findDeclarationInRule;
+    private buildAtRuleString;
+    private sortDeclarations;
+}
+export {};

package/dist/elements/services/stylesheetService/CssTreeStylesheetService.js

@@ -1,198 +1,198 @@
-import { calculate as calculateSpecifity } from "./SpecificityCalculator.js";
-import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
-export class CssTreeStylesheetService extends AbstractStylesheetService {
-    constructor(designerCanvas) {
-        super(designerCanvas);
-    }
-    async internalParse(style) {
-        return window.csstree.toPlainObject((window.csstree.parse(style, { positions: true, parseValue: false })));
-    }
-    /* Section covers the retrieval of rules and declarations */
-    getAppliedRulesInternal(designItem) {
-        let styles = [];
-        for (let item of this._allStylesheets) {
-            if (!item[1].ast || !this.astHasChildren(item[1].ast))
-                continue;
-            styles = styles.concat(Array.from(this.rulesFromAST(item[1].ast, item[1].stylesheet.content, item[0], designItem)));
-        }
-        ;
-        return styles;
-    }
-    getAppliedRules(designItem) {
-        let rules = this.getAppliedRulesInternal(designItem);
-        if (!rules || rules.length == 0)
-            return [];
-        let retCollection = [];
-        for (let rule of rules) {
-            retCollection.push({
-                ...rule,
-                declarations: rule.ast.block.children.map((declaration) => {
-                    return {
-                        name: declaration.property,
-                        value: declaration.value.value,
-                        important: declaration.important == true,
-                        specificity: rule.specificity,
-                        parent: rule,
-                        ast: declaration,
-                    };
-                })
-            });
-        }
-        return retCollection;
-    }
-    getDeclarationInternal(designItem, styleName) {
-        let rules = this.getAppliedRulesInternal(designItem);
-        if (!rules)
-            return null;
-        let declarations = [];
-        for (let rule of rules) {
-            let declaration = this.findDeclarationInRule(rule.ast, styleName);
-            if (!declaration)
-                continue;
-            declarations.push({
-                ast: declaration,
-                parent: rule,
-                name: styleName,
-                value: declaration.value.value,
-                important: declaration.important == true,
-                stylesheet: rule.stylesheet
-            });
-        }
-        ;
-        return declarations;
-    }
-    getDeclarations(designItem, stlyeName) {
-        let declarations = this.getDeclarationInternal(designItem, stlyeName);
-        if (!declarations)
-            return null;
-        return this.sortDeclarations(declarations);
-    }
-    /* Section covers the update of rules and declarations */
-    updateDeclarationValueWithoutUndo(declaration, value, important) {
-        let sourceNode = this._allStylesheets.get(declaration.parent.stylesheetName);
-        declaration.ast.value = window.csstree.toPlainObject(window.csstree.parse(declaration.name + ": " + value + (important ? " !important" : ""), { context: 'declaration', parseValue: false })).value;
-        const old = sourceNode.stylesheet.content;
-        sourceNode.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(sourceNode.ast));
-        // After generating the stylesheet, parse again (so line numbers are correct)
-        sourceNode.ast = window.csstree.toPlainObject((window.csstree.parse(sourceNode.stylesheet.content, { positions: true, parseValue: false })));
-        if (sourceNode.stylesheet.designItem) {
-            sourceNode.stylesheet.designItem.content = sourceNode.stylesheet.content;
-        }
-        else
-            this.stylesheetChanged.emit({ name: sourceNode.stylesheet.name, newStyle: sourceNode.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
-    }
-    insertDeclarationIntoRule(rule, property, value, important) {
-        let sourceNode = this._allStylesheets.get(rule.stylesheetName);
-        rule.ast.block.children.push(window.csstree.toPlainObject(window.csstree.parse(property + ": " + value + (important ? " !important" : ""), { context: 'declaration', parseValue: false })));
-        const old = sourceNode.stylesheet.content;
-        sourceNode.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(sourceNode.ast));
-        // After generating the stylesheet, parse again (so line numbers are correct)
-        sourceNode.ast = window.csstree.toPlainObject((window.csstree.parse(sourceNode.stylesheet.content, { positions: true, parseValue: false })));
-        if (sourceNode.stylesheet.designItem) {
-            sourceNode.stylesheet.designItem.content = sourceNode.stylesheet.content;
-        }
-        else
-            this.stylesheetChanged.emit({ name: sourceNode.stylesheet.name, newStyle: sourceNode.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
-        return true;
-    }
-    removeDeclarationFromRule(rule, property) {
-        let index = rule.ast.block.children.findIndex(x => x.property == property);
-        if (index == -1)
-            return false;
-        rule.ast.block.children.splice(index, 1);
-        const ss = this._allStylesheets.get(rule.stylesheetName);
-        const old = ss.stylesheet.content;
-        ss.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(this._allStylesheets.get(rule.stylesheetName).ast));
-        // After generating the stylesheet, parse again (so line numbers are correct)
-        ss.ast = window.csstree.toPlainObject((window.csstree.parse(this._allStylesheets.get(rule.stylesheetName).stylesheet.content, { positions: true, parseValue: false })));
-        if (ss.stylesheet.designItem) {
-            ss.stylesheet.designItem.content = ss.stylesheet.content;
-        }
-        else
-            this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
-        return true;
-    }
-    updateCompleteStylesheet(name, newStyle) {
-        const ss = this._allStylesheets.get(name);
-        if (ss.stylesheet.content != newStyle) {
-            const old = ss.stylesheet.content;
-            ss.stylesheet.content = newStyle;
-            if (ss.stylesheet.designItem) {
-                ss.stylesheet.designItem.content = ss.stylesheet.content;
-            }
-            else
-                this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
-        }
-    }
-    /* Section covers the internal traversal creation of rules and declarations */
-    *rulesFromAST(ast, stylesheet, source, designItem, previousCheck = '') {
-        let parent = ast["children"] != null ? ast : ast.block;
-        for (const child of parent.children) {
-            if (child.type == "Atrule") {
-                const currentCheck = this.buildAtRuleString(child, stylesheet);
-                if (currentCheck.type === "@media" && !window.matchMedia(currentCheck.sel))
-                    continue;
-                if (currentCheck.type === "@supports" && !CSS.supports(currentCheck.sel))
-                    continue;
-                let ruleCollection = this.rulesFromAST(child, stylesheet, source, designItem, previousCheck + currentCheck.type + " " + currentCheck.sel + "\n");
-                if (ruleCollection) {
-                    for (const r of ruleCollection) {
-                        if (!this.elementMatchesASelector(designItem, this.buildSelectorString(r.ast.prelude, stylesheet)))
-                            continue;
-                        yield r;
-                    }
-                }
-            }
-            if (child.type == "Rule") {
-                let selectors = this.buildSelectorString(child.prelude, stylesheet);
-                if (!this.elementMatchesASelector(designItem, selectors))
-                    continue;
-                yield ({
-                    ast: child,
-                    selector: previousCheck + this.buildSelectorString(child.prelude, stylesheet).join(", "),
-                    specificity: this.getSpecificity(child.prelude),
-                    stylesheetName: source,
-                    declarations: null,
-                    stylesheet: this._allStylesheets.get(source).stylesheet
-                });
-            }
-        }
-        ;
-    }
-    /* Utility functions for building selectors, specificity and so on  */
-    astHasChildren(ast) {
-        return ast != null && ast["children"] != null && ast["children"].length > 0;
-    }
-    buildSelectorString(selectorsAST, stylesheet) {
-        if (selectorsAST.type == 'SelectorList') {
-            return [...selectorsAST.children.map(x => this.buildSelectorString(x, stylesheet)[0])];
-        }
-        else {
-            return [stylesheet.substring(selectorsAST.loc.start.offset, selectorsAST.loc.end.offset)];
-        }
-    }
-    getSpecificity(selector) {
-        const specificities = calculateSpecifity(selector);
-        let sum = 0;
-        specificities.forEach(specificity => sum += specificity.a * 10000 + specificity.b * 100 + specificity.c);
-        return sum;
-    }
-    findDeclarationInRule(rule, styleName) {
-        return rule.block.children.find(declaration => declaration.property == styleName);
-    }
-    buildAtRuleString(ast, stylesheet) {
-        return {
-            sel: stylesheet.slice(ast.prelude.loc.start.offset, ast.prelude.loc.end.offset),
-            type: "@" + ast.name
-        };
-    }
-    sortDeclarations(declarations) {
-        if (declarations == null || declarations.length == 0)
-            return null;
-        return declarations.sort((dec1, dec2) => {
-            if (dec1.parent.specificity > dec2.parent.specificity)
-                return -1;
-            return 1;
-        });
-    }
-}
+import { calculate as calculateSpecifity } from "./SpecificityCalculator.js";
+import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
+export class CssTreeStylesheetService extends AbstractStylesheetService {
+    constructor(designerCanvas) {
+        super(designerCanvas);
+    }
+    async internalParse(style) {
+        return window.csstree.toPlainObject((window.csstree.parse(style, { positions: true, parseValue: false })));
+    }
+    /* Section covers the retrieval of rules and declarations */
+    getAppliedRulesInternal(designItem) {
+        let styles = [];
+        for (let item of this._allStylesheets) {
+            if (!item[1].ast || !this.astHasChildren(item[1].ast))
+                continue;
+            styles = styles.concat(Array.from(this.rulesFromAST(item[1].ast, item[1].stylesheet.content, item[0], designItem)));
+        }
+        ;
+        return styles;
+    }
+    getAppliedRules(designItem) {
+        let rules = this.getAppliedRulesInternal(designItem);
+        if (!rules || rules.length == 0)
+            return [];
+        let retCollection = [];
+        for (let rule of rules) {
+            retCollection.push({
+                ...rule,
+                declarations: rule.ast.block.children.map((declaration) => {
+                    return {
+                        name: declaration.property,
+                        value: declaration.value.value,
+                        important: declaration.important == true,
+                        specificity: rule.specificity,
+                        parent: rule,
+                        ast: declaration,
+                    };
+                })
+            });
+        }
+        return retCollection;
+    }
+    getDeclarationInternal(designItem, styleName) {
+        let rules = this.getAppliedRulesInternal(designItem);
+        if (!rules)
+            return null;
+        let declarations = [];
+        for (let rule of rules) {
+            let declaration = this.findDeclarationInRule(rule.ast, styleName);
+            if (!declaration)
+                continue;
+            declarations.push({
+                ast: declaration,
+                parent: rule,
+                name: styleName,
+                value: declaration.value.value,
+                important: declaration.important == true,
+                stylesheet: rule.stylesheet
+            });
+        }
+        ;
+        return declarations;
+    }
+    getDeclarations(designItem, stlyeName) {
+        let declarations = this.getDeclarationInternal(designItem, stlyeName);
+        if (!declarations)
+            return null;
+        return this.sortDeclarations(declarations);
+    }
+    /* Section covers the update of rules and declarations */
+    updateDeclarationValueWithoutUndo(declaration, value, important) {
+        let sourceNode = this._allStylesheets.get(declaration.parent.stylesheetName);
+        declaration.ast.value = window.csstree.toPlainObject(window.csstree.parse(declaration.name + ": " + value + (important ? " !important" : ""), { context: 'declaration', parseValue: false })).value;
+        const old = sourceNode.stylesheet.content;
+        sourceNode.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(sourceNode.ast));
+        // After generating the stylesheet, parse again (so line numbers are correct)
+        sourceNode.ast = window.csstree.toPlainObject((window.csstree.parse(sourceNode.stylesheet.content, { positions: true, parseValue: false })));
+        if (sourceNode.stylesheet.designItem) {
+            sourceNode.stylesheet.designItem.content = sourceNode.stylesheet.content;
+        }
+        else
+            this.stylesheetChanged.emit({ name: sourceNode.stylesheet.name, newStyle: sourceNode.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
+    }
+    insertDeclarationIntoRule(rule, property, value, important) {
+        let sourceNode = this._allStylesheets.get(rule.stylesheetName);
+        rule.ast.block.children.push(window.csstree.toPlainObject(window.csstree.parse(property + ": " + value + (important ? " !important" : ""), { context: 'declaration', parseValue: false })));
+        const old = sourceNode.stylesheet.content;
+        sourceNode.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(sourceNode.ast));
+        // After generating the stylesheet, parse again (so line numbers are correct)
+        sourceNode.ast = window.csstree.toPlainObject((window.csstree.parse(sourceNode.stylesheet.content, { positions: true, parseValue: false })));
+        if (sourceNode.stylesheet.designItem) {
+            sourceNode.stylesheet.designItem.content = sourceNode.stylesheet.content;
+        }
+        else
+            this.stylesheetChanged.emit({ name: sourceNode.stylesheet.name, newStyle: sourceNode.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
+        return true;
+    }
+    removeDeclarationFromRule(rule, property) {
+        let index = rule.ast.block.children.findIndex(x => x.property == property);
+        if (index == -1)
+            return false;
+        rule.ast.block.children.splice(index, 1);
+        const ss = this._allStylesheets.get(rule.stylesheetName);
+        const old = ss.stylesheet.content;
+        ss.stylesheet.content = window.csstree.generate(window.csstree.fromPlainObject(this._allStylesheets.get(rule.stylesheetName).ast));
+        // After generating the stylesheet, parse again (so line numbers are correct)
+        ss.ast = window.csstree.toPlainObject((window.csstree.parse(this._allStylesheets.get(rule.stylesheetName).stylesheet.content, { positions: true, parseValue: false })));
+        if (ss.stylesheet.designItem) {
+            ss.stylesheet.designItem.content = ss.stylesheet.content;
+        }
+        else
+            this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
+        return true;
+    }
+    updateCompleteStylesheet(name, newStyle) {
+        const ss = this._allStylesheets.get(name);
+        if (ss.stylesheet.content != newStyle) {
+            const old = ss.stylesheet.content;
+            ss.stylesheet.content = newStyle;
+            if (ss.stylesheet.designItem) {
+                ss.stylesheet.designItem.content = ss.stylesheet.content;
+            }
+            else
+                this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
+        }
+    }
+    /* Section covers the internal traversal creation of rules and declarations */
+    *rulesFromAST(ast, stylesheet, source, designItem, previousCheck = '') {
+        let parent = ast["children"] != null ? ast : ast.block;
+        for (const child of parent.children) {
+            if (child.type == "Atrule") {
+                const currentCheck = this.buildAtRuleString(child, stylesheet);
+                if (currentCheck.type === "@media" && !window.matchMedia(currentCheck.sel))
+                    continue;
+                if (currentCheck.type === "@supports" && !CSS.supports(currentCheck.sel))
+                    continue;
+                let ruleCollection = this.rulesFromAST(child, stylesheet, source, designItem, previousCheck + currentCheck.type + " " + currentCheck.sel + "\n");
+                if (ruleCollection) {
+                    for (const r of ruleCollection) {
+                        if (!this.elementMatchesASelector(designItem, this.buildSelectorString(r.ast.prelude, stylesheet)))
+                            continue;
+                        yield r;
+                    }
+                }
+            }
+            if (child.type == "Rule") {
+                let selectors = this.buildSelectorString(child.prelude, stylesheet);
+                if (!this.elementMatchesASelector(designItem, selectors))
+                    continue;
+                yield ({
+                    ast: child,
+                    selector: previousCheck + this.buildSelectorString(child.prelude, stylesheet).join(", "),
+                    specificity: this.getSpecificity(child.prelude),
+                    stylesheetName: source,
+                    declarations: null,
+                    stylesheet: this._allStylesheets.get(source).stylesheet
+                });
+            }
+        }
+        ;
+    }
+    /* Utility functions for building selectors, specificity and so on  */
+    astHasChildren(ast) {
+        return ast != null && ast["children"] != null && ast["children"].length > 0;
+    }
+    buildSelectorString(selectorsAST, stylesheet) {
+        if (selectorsAST.type == 'SelectorList') {
+            return [...selectorsAST.children.map(x => this.buildSelectorString(x, stylesheet)[0])];
+        }
+        else {
+            return [stylesheet.substring(selectorsAST.loc.start.offset, selectorsAST.loc.end.offset)];
+        }
+    }
+    getSpecificity(selector) {
+        const specificities = calculateSpecifity(selector);
+        let sum = 0;
+        specificities.forEach(specificity => sum += specificity.a * 10000 + specificity.b * 100 + specificity.c);
+        return sum;
+    }
+    findDeclarationInRule(rule, styleName) {
+        return rule.block.children.find(declaration => declaration.property == styleName);
+    }
+    buildAtRuleString(ast, stylesheet) {
+        return {
+            sel: stylesheet.slice(ast.prelude.loc.start.offset, ast.prelude.loc.end.offset),
+            type: "@" + ast.name
+        };
+    }
+    sortDeclarations(declarations) {
+        if (declarations == null || declarations.length == 0)
+            return null;
+        return declarations.sort((dec1, dec2) => {
+            if (dec1.parent.specificity > dec2.parent.specificity)
+                return -1;
+            return 1;
+        });
+    }
+}

package/dist/elements/services/stylesheetService/IStylesheetService.d.ts

@@ -1,41 +1,41 @@
-import { TypedEvent } from "@node-projects/base-custom-webcomponent";
-import { IDesignItem } from "../../item/IDesignItem.js";
-export interface IStyleRule {
-    selector: string;
-    declarations: IStyleDeclaration[];
-    specificity: number;
-    stylesheetName?: string;
-}
-export interface IStyleDeclaration {
-    name: string;
-    value: string;
-    important: boolean;
-    parent: IStyleRule;
-    stylesheet?: IStylesheet;
-}
-export interface IStylesheet {
-    content: string;
-    name: string;
-}
-export interface IDocumentStylesheet extends IStylesheet {
-    designItem: IDesignItem;
-}
-export interface IStylesheetService {
-    setStylesheets(stylesheets: IStylesheet[]): Promise<void>;
-    getStylesheets(): IStylesheet[];
-    setDocumentStylesheets(stylesheets: IDocumentStylesheet[]): Promise<void>;
-    getAppliedRules(designItem: IDesignItem): IStyleRule[];
-    getDeclarations(designItem: IDesignItem, styleName: string): IStyleDeclaration[];
-    updateDeclarationValue(declaration: IStyleDeclaration, value: string, important: boolean): any;
-    updateDeclarationValueWithoutUndo(declaration: IStyleDeclaration, value: string, important: boolean): any;
-    insertDeclarationIntoRule(rule: IStyleRule, property: string, value: string, important: boolean): boolean;
-    removeDeclarationFromRule(rule: IStyleRule, property: string): boolean;
-    updateCompleteStylesheet(name: string, newStyle: string): void;
-    stylesheetChanged: TypedEvent<{
-        name: string;
-        newStyle: string;
-        oldStyle: string;
-        changeSource: 'extern' | 'styleupdate';
-    }>;
-    stylesheetsChanged: TypedEvent<void>;
-}
+import { TypedEvent } from "@node-projects/base-custom-webcomponent";
+import { IDesignItem } from "../../item/IDesignItem.js";
+export interface IStyleRule {
+    selector: string;
+    declarations: IStyleDeclaration[];
+    specificity: number;
+    stylesheetName?: string;
+}
+export interface IStyleDeclaration {
+    name: string;
+    value: string;
+    important: boolean;
+    parent: IStyleRule;
+    stylesheet?: IStylesheet;
+}
+export interface IStylesheet {
+    content: string;
+    name: string;
+}
+export interface IDocumentStylesheet extends IStylesheet {
+    designItem: IDesignItem;
+}
+export interface IStylesheetService {
+    setStylesheets(stylesheets: IStylesheet[]): Promise<void>;
+    getStylesheets(): IStylesheet[];
+    setDocumentStylesheets(stylesheets: IDocumentStylesheet[]): Promise<void>;
+    getAppliedRules(designItem: IDesignItem): IStyleRule[];
+    getDeclarations(designItem: IDesignItem, styleName: string): IStyleDeclaration[];
+    updateDeclarationValue(declaration: IStyleDeclaration, value: string, important: boolean): any;
+    updateDeclarationValueWithoutUndo(declaration: IStyleDeclaration, value: string, important: boolean): any;
+    insertDeclarationIntoRule(rule: IStyleRule, property: string, value: string, important: boolean): boolean;
+    removeDeclarationFromRule(rule: IStyleRule, property: string): boolean;
+    updateCompleteStylesheet(name: string, newStyle: string): void;
+    stylesheetChanged: TypedEvent<{
+        name: string;
+        newStyle: string;
+        oldStyle: string;
+        changeSource: 'extern' | 'styleupdate';
+    }>;
+    stylesheetsChanged: TypedEvent<void>;
+}

package/dist/elements/services/stylesheetService/IStylesheetService.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/elements/services/stylesheetService/SpecificityCalculator.d.ts

@@ -1,7 +1,7 @@
-type Specificity = {
-    a: 0;
-    b: 0;
-    c: 0;
-};
-declare const calculate: (selectorAST: any) => Specificity[];
-export { calculate };
+type Specificity = {
+    a: 0;
+    b: 0;
+    c: 0;
+};
+declare const calculate: (selectorAST: any) => Specificity[];
+export { calculate };