happy-dom 15.7.4 → 15.8.0

package/cjs/css/declaration/CSSStyleDeclaration.cjs

@@ -1,17 +1,73 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractCSSStyleDeclaration_js_1 = __importDefault(require("./AbstractCSSStyleDeclaration.cjs"));
-/* eslint-disable jsdoc/require-jsdoc */
+const DOMExceptionNameEnum_js_1 = __importDefault(require("../../exception/DOMExceptionNameEnum.cjs"));
+const CSSStyleDeclarationPropertyManager_js_1 = __importDefault(require("./property-manager/CSSStyleDeclarationPropertyManager.cjs"));
+const PropertySymbol = __importStar(require("../../PropertySymbol.cjs"));
+const CSSStyleDeclarationComputedStyle_js_1 = __importDefault(require("./computed-style/CSSStyleDeclarationComputedStyle.cjs"));
 /**
  * CSS Style Declaration.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration
  */
-class CSSStyleDeclaration extends AbstractCSSStyleDeclaration_js_1.default {
+class CSSStyleDeclaration {
+    // Public properties
+    parentRule = null;
+    // Internal properties
+    [PropertySymbol.window];
+    // Private properties
+    #element;
+    #computed;
+    #cache = {
+        attributeValue: null,
+        propertyManager: null
+    };
+    /**
+     * Constructor.
+     *
+     * @param illegalConstructorSymbol Illegal constructor symbol.
+     * @param window Window.
+     * @param [options] Options.
+     * @param [options.element] Element.
+     * @param [options.computed] Computed.
+     */
+    constructor(illegalConstructorSymbol, window, options) {
+        if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+            throw new TypeError('Illegal constructor');
+        }
+        this[PropertySymbol.window] = window;
+        this.#element = options?.element;
+        this.#computed = options?.element ? !!options?.computed : false;
+    }
     /**
      * Index properties
      */
+    /* eslint-disable jsdoc/require-jsdoc */
     get 0() {
         return this.item(0) || undefined;
     }
@@ -3561,6 +3617,149 @@ class CSSStyleDeclaration extends AbstractCSSStyleDeclaration_js_1.default {
     set containerName(value) {
         this.setProperty('container-name', value);
     }
+    /* eslint-enable jsdoc/require-jsdoc */
+    /**
+     * Returns length.
+     *
+     * @returns Length.
+     */
+    get length() {
+        return this.#getPropertyManager().size();
+    }
+    /**
+     * Returns the style decleration as a CSS text.
+     *
+     * @returns CSS text.
+     */
+    get cssText() {
+        if (this.#element && this.#computed) {
+            return '';
+        }
+        return this.#getPropertyManager().toString();
+    }
+    /**
+     * Sets CSS text.
+     *
+     * @param cssText CSS text.
+     */
+    set cssText(cssText) {
+        if (this.#computed) {
+            throw new this[PropertySymbol.window].DOMException(`Failed to execute 'cssText' on 'CSSStyleDeclaration': These styles are computed, and the properties are therefore read-only.`, DOMExceptionNameEnum_js_1.default.domException);
+        }
+        if (this.#element) {
+            this.#cache.propertyManager = new CSSStyleDeclarationPropertyManager_js_1.default({ cssText });
+            this.#cache.attributeValue = cssText;
+            this.#element.setAttribute('style', this.#cache.propertyManager.toString());
+        }
+        else {
+            this.#cache.propertyManager = new CSSStyleDeclarationPropertyManager_js_1.default({ cssText });
+        }
+    }
+    /**
+     * Returns item.
+     *
+     * @param index Index.
+     * @returns Item.
+     */
+    item(index) {
+        return this.#getPropertyManager().item(index);
+    }
+    /**
+     * Set a property.
+     *
+     * @param name Property name.
+     * @param value Value. Must not contain "!important" as that should be set using the priority parameter.
+     * @param [priority] Can be "important", or an empty string.
+     */
+    setProperty(name, value, priority) {
+        if (this.#computed) {
+            throw new this[PropertySymbol.window].DOMException(`Failed to execute 'setProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`, DOMExceptionNameEnum_js_1.default.domException);
+        }
+        if (priority !== '' && priority !== undefined && priority !== 'important') {
+            return;
+        }
+        const stringValue = String(value).trim();
+        const propertyManager = this.#getPropertyManager();
+        if (stringValue) {
+            propertyManager.set(name, stringValue, !!priority);
+        }
+        else {
+            propertyManager.remove(name);
+        }
+        if (this.#element) {
+            this.#cache.attributeValue = propertyManager.toString();
+            if (this.#cache.attributeValue) {
+                this.#element.setAttribute('style', this.#cache.attributeValue);
+            }
+            else {
+                this.#element.removeAttribute('style');
+            }
+        }
+    }
+    /**
+     * Removes a property.
+     *
+     * @param name Property name in kebab case.
+     * @param value Value. Must not contain "!important" as that should be set using the priority parameter.
+     * @param [priority] Can be "important", or an empty string.
+     */
+    removeProperty(name) {
+        if (this.#computed) {
+            throw new this[PropertySymbol.window].DOMException(`Failed to execute 'removeProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`, DOMExceptionNameEnum_js_1.default.domException);
+        }
+        const propertyManager = this.#getPropertyManager();
+        propertyManager.remove(name);
+        if (this.#element) {
+            this.#cache.attributeValue = propertyManager.toString();
+            if (this.#cache.attributeValue) {
+                this.#element.setAttribute('style', this.#cache.attributeValue);
+            }
+            else {
+                this.#element.removeAttribute('style');
+            }
+        }
+    }
+    /**
+     * Returns a property.
+     *
+     * @param name Property name in kebab case.
+     * @returns Property value.
+     */
+    getPropertyValue(name) {
+        return this.#getPropertyManager().get(name)?.value || '';
+    }
+    /**
+     * Returns a property.
+     *
+     * @param name Property name in kebab case.
+     * @returns "important" if set to be important.
+     */
+    getPropertyPriority(name) {
+        return this.#getPropertyManager().get(name)?.important ? 'important' : '';
+    }
+    /**
+     * Returns property manager.
+     *
+     * @returns Property manager.
+     */
+    #getPropertyManager() {
+        const element = this.#element;
+        const cache = this.#cache;
+        if (!element) {
+            if (!cache.propertyManager) {
+                cache.propertyManager = new CSSStyleDeclarationPropertyManager_js_1.default();
+            }
+            return cache.propertyManager;
+        }
+        if (this.#computed) {
+            return new CSSStyleDeclarationComputedStyle_js_1.default(element).getComputedStyle();
+        }
+        const attributeValue = element[PropertySymbol.attributes][PropertySymbol.namedItems].get('style')?.[PropertySymbol.value];
+        if (cache.attributeValue !== attributeValue) {
+            cache.propertyManager = new CSSStyleDeclarationPropertyManager_js_1.default({ cssText: attributeValue });
+        }
+        return cache.propertyManager;
+    }
 }
 exports.default = CSSStyleDeclaration;
 //# sourceMappingURL=CSSStyleDeclaration.cjs.map