@postnord/pn-marketweb-components 4.3.6 → 4.3.8

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/hydrate/runner.js

@@ -1,5 +1,5 @@
 /*
- Stencil Hydrate Runner v4.41.3 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Runner v4.43.2 | MIT Licensed | https://stenciljs.com
  */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -11296,6 +11296,9 @@ var MockElement = class extends MockNode2 {
   get part() {
     return new MockTokenList(this, "part");
   }
+  set part(value) {
+    this.setAttributeNS(null, "part", String(value));
+  }
   click() {
     dispatchEvent(this, new MockEvent("click", { bubbles: true, cancelable: true, composed: true }));
   }
@@ -12173,6 +12176,8 @@ function createElement(ownerDocument, tagName) {
       return new MockImageElement(ownerDocument);
     case "input":
       return new MockInputElement(ownerDocument);
+    case "label":
+      return new MockLabelElement(ownerDocument);
     case "link":
       return new MockLinkElement(ownerDocument);
     case "meta":
@@ -12251,6 +12256,9 @@ var MockButtonElement = class extends MockHTMLElement {
   constructor(ownerDocument) {
     super(ownerDocument, "button");
   }
+  get labels() {
+    return getLabelsForElement(this);
+  }
 };
 patchPropAttributes(
   MockButtonElement.prototype,
@@ -12298,6 +12306,9 @@ var MockInputElement = class extends MockHTMLElement {
     }
     return null;
   }
+  get labels() {
+    return getLabelsForElement(this);
+  }
 };
 patchPropAttributes(
   MockInputElement.prototype,
@@ -12346,6 +12357,26 @@ var MockFormElement = class extends MockHTMLElement {
 patchPropAttributes(MockFormElement.prototype, {
   name: String
 });
+var MockLabelElement = class extends MockHTMLElement {
+  constructor(ownerDocument) {
+    super(ownerDocument, "label");
+  }
+  get htmlFor() {
+    return this.getAttributeNS(null, "for") || "";
+  }
+  set htmlFor(value) {
+    this.setAttributeNS(null, "for", value);
+  }
+  get control() {
+    var _a2, _b;
+    const forAttr = this.htmlFor;
+    if (forAttr) {
+      return (_b = (_a2 = this.ownerDocument) == null ? void 0 : _a2.getElementById(forAttr)) != null ? _b : null;
+    }
+    const labelableSelector = 'button, input:not([type="hidden"]), meter, output, progress, select, textarea';
+    return this.querySelector(labelableSelector);
+  }
+};
 var MockLinkElement = class extends MockHTMLElement {
   constructor(ownerDocument) {
     super(ownerDocument, "link");
@@ -12756,6 +12787,30 @@ function fullUrl(elm, attrName) {
   }
   return val.replace(/\'|\"/g, "").trim();
 }
+function getLabelsForElement(elm) {
+  const labels = [];
+  const id = elm.id;
+  const doc = elm.ownerDocument;
+  if (doc) {
+    if (id) {
+      const allLabels = doc.getElementsByTagName("label");
+      for (let i = 0; i < allLabels.length; i++) {
+        const label = allLabels[i];
+        if (label.htmlFor === id) {
+          labels.push(label);
+        }
+      }
+    }
+    let parent = elm.parentNode;
+    while (parent) {
+      if (parent.nodeName === "LABEL" && !labels.includes(parent)) {
+        labels.push(parent);
+      }
+      parent = parent.parentNode;
+    }
+  }
+  return labels;
+}
 function patchPropAttributes(prototype, attrs, defaults2 = {}) {
   Object.keys(attrs).forEach((propName) => {
     const attr = attrs[propName];
@@ -13446,7 +13501,6 @@ var MockWindow = class {
   __timeouts;
   __history;
   __elementCstr;
-  __htmlElementCstr;
   __charDataCstr;
   __docTypeCstr;
   __docCstr;
@@ -13653,27 +13707,10 @@ var MockWindow = class {
     return JSON;
   }
   get HTMLElement() {
-    if (this.__htmlElementCstr == null) {
-      const ownerDocument = this.document;
-      this.__htmlElementCstr = class extends MockHTMLElement {
-        constructor() {
-          super(ownerDocument, "");
-          const observedAttributes = this.constructor.observedAttributes;
-          if (Array.isArray(observedAttributes) && typeof this.attributeChangedCallback === "function") {
-            observedAttributes.forEach((attrName) => {
-              const attrValue = this.getAttribute(attrName);
-              if (attrValue != null) {
-                this.attributeChangedCallback(attrName, null, attrValue);
-              }
-            });
-          }
-        }
-      };
-    }
-    return this.__htmlElementCstr;
+    return MockHTMLElement;
   }
-  set HTMLElement(htmlElementCstr) {
-    this.__htmlElementCstr = htmlElementCstr;
+  get SVGElement() {
+    return MockSVGElement;
   }
   get IntersectionObserver() {
     return MockIntersectionObserver;

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stencil/core/internal",
-  "version": "4.41.3",
+  "version": "4.43.2",
   "description": "Stencil internals only to be imported by the Stencil Compiler. Breaking changes can and will happen at any time.",
   "main": "./index.js",
   "types": "./index.d.ts",

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-core/index.d.ts

@@ -47,6 +47,7 @@ export {
   Prop,
   readTask,
   render,
+  resolveVar,
   setAssetPath,
   setErrorHandler,
   setMode,

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-ext-modules.d.ts

@@ -1,5 +1,5 @@
 declare module '*.css' {
-  const src: string;
+  const src: () => string;
   export default src;
 }
 

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-private.d.ts

@@ -374,6 +374,12 @@ export interface CollectionCompilerVersion {
 }
 export interface CollectionManifest {
     entries?: CollectionComponentEntryPath[];
+    /**
+     * Paths to mixin/abstract class modules that can be extended by consuming projects.
+     * These are modules that contain classes with Stencil static members (properties, states, etc.)
+     * but are not components themselves (no @Component decorator / tag name).
+     */
+    mixins?: CollectionComponentEntryPath[];
     collections?: CollectionDependencyManifest[];
     global?: string;
     compiler?: CollectionCompilerVersion;
@@ -521,6 +527,11 @@ export interface ComponentCompilerMeta extends ComponentCompilerFeatures {
      * `null` then `attachInternals` should not be called.
      */
     attachInternalsMemberName: string | null;
+    /**
+     * Custom states to initialize on the ElementInternals.states CustomStateSet.
+     * These are defined via @AttachInternals({ states: {...} }).
+     */
+    attachInternalsCustomStates: ComponentCompilerCustomState[];
     componentClassName: string;
     /**
      * A list of web component tag names that are either:
@@ -741,6 +752,26 @@ export interface ComponentCompilerMethod extends ComponentCompilerStaticMethod {
 export interface ComponentCompilerState {
     name: string;
 }
+/**
+ * Metadata about a custom state defined via @AttachInternals({ states: {...} })
+ *
+ * Custom states are exposed via the ElementInternals.states CustomStateSet
+ * and can be targeted with the CSS :state() pseudo-class.
+ */
+export interface ComponentCompilerCustomState {
+    /**
+     * The name of the custom state (without dashes)
+     */
+    name: string;
+    /**
+     * The initial value of the state
+     */
+    initialValue: boolean;
+    /**
+     * Optional JSDoc description for the state
+     */
+    docs: string;
+}
 /**
  * Representation of JSDoc that is pulled off a node in the AST
  */
@@ -1114,6 +1145,11 @@ export interface Module {
     cmps: ComponentCompilerMeta[];
     isMixin: boolean;
     isExtended: boolean;
+    /**
+     * Indicates this module contains mixin/abstract classes that can be extended by other projects.
+     * These are classes with Stencil static members (properties, states, etc.) but no @Component decorator.
+     */
+    hasExportableMixins: boolean;
     /**
      * A collection of modules that a component will need. The modules in this list must have import statements generated
      * in order for the component to function.
@@ -1135,6 +1171,12 @@ export interface Module {
     isLegacy: boolean;
     jsFilePath: string;
     localImports: string[];
+    /**
+     * Source file paths of functional components that are used in JSX/h() calls.
+     * This is used to ensure htmlTagNames are properly propagated from functional
+     * component dependencies even when they're accessed indirectly (e.g., via barrel files).
+     */
+    functionalComponentDeps: string[];
     originalImports: string[];
     originalCollectionComponentPath: string;
     potentialCmpRefs: string[];
@@ -2335,6 +2377,13 @@ export interface TypesModule {
     component: string;
     jsx: string;
     element: string;
+    explicitAttributes: string | null;
+    explicitProperties: string | null;
+    requiredProps: Array<{
+        name: string;
+        type: string;
+        complexType?: ComponentCompilerProperty['complexType'];
+    }> | null;
 }
 export type TypeInfo = {
     name: string;

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-public-compiler.d.ts

@@ -2171,6 +2171,13 @@ export interface OutputTargetDistLazyLoader extends OutputTargetBase {
 export interface OutputTargetHydrate extends OutputTargetBase {
     type: 'dist-hydrate-script';
     dir?: string;
+    /**
+     * Whether to generate a package.json file in the hydrate output directory.
+     * Defaults to `true`
+     * @deprecated
+     * In the next major release, the `package.json` file will be completely removed from the `dist-hydrate-script` output (use `exports` from your library's main `package.json`)
+     */
+    generatePackageJson?: boolean;
     /**
      * Module IDs that should not be bundled into the script.
      * By default, all node builtin's, such as `fs` or `path`
@@ -2263,6 +2270,15 @@ export interface OutputTargetDocsJson extends OutputTargetBase {
      */
     supplementalPublicTypes?: string;
 }
+export interface OutputTargetDocsCustomElementsManifest extends OutputTargetBase {
+    type: 'docs-custom-elements-manifest';
+    /**
+     * The file path where the custom-elements.json manifest will be written.
+     * Defaults to 'custom-elements.json' in the root directory.
+     */
+    file: string;
+    strict?: boolean;
+}
 export interface OutputTargetDocsCustom extends OutputTargetBase {
     type: 'docs-custom';
     generator: (docs: JsonDocs, config: Config) => void | Promise<void>;
@@ -2321,6 +2337,40 @@ export interface OutputTargetDistCustomElements extends OutputTargetValidationCo
      * If omitted, no auto-definition behavior or re-exporting will happen.
      */
     customElementsExportBehavior?: CustomElementsExportBehavior;
+    /**
+     * Generate an auto-loader script that uses MutationObserver to lazily load
+     * and define custom elements as they appear in the DOM.
+     *
+     * When set to `true`, generates a `loader.js` file that auto-starts on import.
+     * Can also be configured with an object for more control:
+     * - `fileName`: Custom filename for the loader (default: 'loader.js')
+     * - `autoStart`: Whether to auto-start the loader on import (default: true)
+     *
+     * @example
+     * ```typescript
+     * // Simple usage
+     * autoLoader: true
+     *
+     * // With options
+     * autoLoader: {
+     *   fileName: 'my-loader.js',
+     *   autoStart: false
+     * }
+     * ```
+     */
+    autoLoader?: boolean | {
+        /**
+         * Custom filename for the generated loader script.
+         * @default 'loader.js'
+         */
+        fileName?: string;
+        /**
+         * Whether to automatically start the loader when the script is imported.
+         * If false, you must call `start()` manually.
+         * @default true
+         */
+        autoStart?: boolean;
+    };
 }
 /**
  * The base type for output targets. All output targets should extend this base type.
@@ -2419,7 +2469,7 @@ export interface OutputTargetWww extends OutputTargetBase {
     serviceWorker?: ServiceWorkerConfig | null | false;
     appDir?: string;
 }
-export type OutputTarget = OutputTargetCopy | OutputTargetCustom | OutputTargetDist | OutputTargetDistCollection | OutputTargetDistCustomElements | OutputTargetDistLazy | OutputTargetDistGlobalStyles | OutputTargetDistLazyLoader | OutputTargetDocsJson | OutputTargetDocsCustom | OutputTargetDocsReadme | OutputTargetDocsVscode | OutputTargetWww | OutputTargetHydrate | OutputTargetStats | OutputTargetDistTypes;
+export type OutputTarget = OutputTargetCopy | OutputTargetCustom | OutputTargetDist | OutputTargetDistCollection | OutputTargetDistCustomElements | OutputTargetDistLazy | OutputTargetDistGlobalStyles | OutputTargetDistLazyLoader | OutputTargetDocsJson | OutputTargetDocsCustom | OutputTargetDocsReadme | OutputTargetDocsVscode | OutputTargetDocsCustomElementsManifest | OutputTargetWww | OutputTargetHydrate | OutputTargetStats | OutputTargetDistTypes;
 /**
  * Our custom configuration interface for generated caching Service Workers
  * using the Workbox library (see https://developer.chrome.com/docs/workbox/).

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-public-docs.d.ts

@@ -202,6 +202,10 @@ export interface JsonDocsComponent {
 	 * Array of component Parts information, generate from `@part` tags
 	 */
 	parts: JsonDocsPart[];
+	/**
+	 * Array of custom states defined via @AttachInternals({ states: {...} })
+	 */
+	customStates: JsonDocsCustomState[];
 	/**
 	 * Array of metadata describing where the current component is used
 	 */
@@ -419,6 +423,28 @@ export interface JsonDocsPart {
 	 */
 	docs: string;
 }
+/**
+ * A descriptor for a Custom State defined via @AttachInternals({ states: {...} })
+ *
+ * Custom states are exposed via the ElementInternals.states CustomStateSet
+ * and can be targeted with the CSS `:state()` pseudo-class.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+ */
+export interface JsonDocsCustomState {
+	/**
+	 * The name of the custom state (without dashes)
+	 */
+	name: string;
+	/**
+	 * The initial/default value of the state
+	 */
+	initialValue: boolean;
+	/**
+	 * A textual description of the custom state
+	 */
+	docs: string;
+}
 /**
  * Represents a parsed block comment in a CSS, Sass, etc. file for a custom property.
  */

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/internal/stencil-public-runtime.d.ts

@@ -125,8 +125,27 @@ export interface EventOptions {
      */
     composed?: boolean;
 }
+export interface AttachInternalsOptions {
+    /**
+     * Initial custom states to set on the ElementInternals.states CustomStateSet.
+     * Each key is the state name and the value is the initial boolean state.
+     *
+     * These states can be targeted with the CSS `:state()` pseudo-class.
+     *
+     * @example
+     * ```tsx
+     * @AttachInternals({ states: { open: true, active: false } })
+     * internals: ElementInternals;
+     * ```
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+     */
+    states?: {
+        [stateName: string]: boolean;
+    };
+}
 export interface AttachInternalsDecorator {
-    (): PropertyDecorator;
+    (opts?: AttachInternalsOptions): PropertyDecorator;
 }
 export interface ListenDecorator {
     (eventName: string, opts?: ListenOptions): CustomMethodDecorator<any>;
@@ -660,6 +679,7 @@ export declare namespace h {
     function h(sel: any, data: VNodeData | null, text: string): VNode;
     function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
     function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+    function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
     namespace JSX {
         interface IntrinsicElements extends LocalJSX.IntrinsicElements, JSXBase.IntrinsicElements {
             [tagName: string]: any;
@@ -673,6 +693,8 @@ export declare function h(sel: any, text: string): VNode;
 export declare function h(sel: any, children: Array<VNode | undefined | null>): VNode;
 export declare function h(sel: any, data: VNodeData | null, text: string): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
+export declare function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+export declare function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
 /**
  * Automatic JSX runtime functions for TypeScript's react-jsx mode.
  * These functions are called automatically by TypeScript when using "jsx": "react-jsx".
@@ -702,7 +724,6 @@ export declare function jsxs(type: any, props: any, key?: string): VNode;
  * @returns a jsx vnode
  */
 export declare function jsxDEV(type: any, props: any, key?: string | number, isStaticChildren?: boolean, source?: any, self?: any): VNode;
-export declare function h(sel: any, data: VNodeData | null, children: VNode): VNode;
 /**
  * A virtual DOM node
  */