@postnord/pn-marketweb-components 2.0.148 → 2.0.150-test

package/types/stencil-public-runtime.d.ts

@@ -133,7 +133,7 @@ export interface ListenOptions {
      */
     passive?: boolean;
 }
-export type ListenTargetOptions = 'body' | 'document' | 'window';
+export declare type ListenTargetOptions = 'body' | 'document' | 'window';
 export interface StateDecorator {
     (): PropertyDecorator;
 }
@@ -214,16 +214,14 @@ export declare const State: StateDecorator;
  * https://stenciljs.com/docs/reactive-data#watch-decorator
  */
 export declare const Watch: WatchDecorator;
-export type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
-export type ErrorHandler = (err: any, element?: HTMLElement) => void;
+export declare type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
+export declare type ErrorHandler = (err: any, element?: HTMLElement) => void;
 /**
  * `setMode()` is used for libraries which provide multiple "modes" for styles.
  */
 export declare const setMode: (handler: ResolutionHandler) => void;
 /**
- * `getMode()` is used for libraries which provide multiple "modes" for styles.
- * @param ref a reference to the node to get styles for
- * @returns the current mode or undefined, if not found
+ * getMode
  */
 export declare function getMode<T = string | undefined>(ref: any): T;
 export declare function setPlatformHelpers(helpers: {
@@ -236,9 +234,6 @@ export declare function setPlatformHelpers(helpers: {
 /**
  * Get the base path to where the assets can be found. Use `setAssetPath(path)`
  * if the path needs to be customized.
- * @param path the path to use in calculating the asset path. this value will be
- * used in conjunction with the base asset path
- * @returns the base path
  */
 export declare function getAssetPath(path: string): string;
 /**
@@ -251,38 +246,22 @@ export declare function getAssetPath(path: string): string;
  * `setAssetPath(document.currentScript.src)`, or using a bundler's replace plugin to
  * dynamically set the path at build time, such as `setAssetPath(process.env.ASSET_PATH)`.
  * But do note that this configuration depends on how your script is bundled, or lack of
- * bundling, and where your assets can be loaded from. Additionally custom bundling
+ * bunding, and where your assets can be loaded from. Additionally custom bundling
  * will have to ensure the static assets are copied to its build directory.
- * @param path the asset path to set
- * @returns the set path
  */
 export declare function setAssetPath(path: string): string;
 /**
- * Used to specify a nonce value that corresponds with an application's
- * [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP).
- * When set, the nonce will be added to all dynamically created script and style tags at runtime.
- * Alternatively, the nonce value can be set on a `meta` tag in the DOM head
- * (<meta name="csp-nonce" content="{ nonce value here }" />) and will result in the same behavior.
- * @param nonce The value to be used for the nonce attribute.
- */
-export declare function setNonce(nonce: string): void;
-/**
- * Retrieve a Stencil element for a given reference
- * @param ref the ref to get the Stencil element for
- * @returns a reference to the element
+ * getElement
  */
 export declare function getElement(ref: any): HTMLStencilElement;
 /**
  * Schedules a new render of the given instance or element even if no state changed.
  *
- * Notice `forceUpdate()` is not synchronous and might perform the DOM render in the next frame.
- *
- * @param ref the node/element to force the re-render of
+ * Notice `forceUpdate()` is not syncronous and might perform the DOM render in the next frame.
  */
 export declare function forceUpdate(ref: any): void;
 /**
  * getRenderingRef
- * @returns the rendering ref
  */
 export declare function getRenderingRef(): any;
 export interface HTMLStencilElement extends HTMLElement {
@@ -293,8 +272,6 @@ export interface HTMLStencilElement extends HTMLElement {
  * in the best moment to perform DOM mutation without causing layout thrashing.
  *
  * For further information: https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing
- *
- * @param task the DOM-write to schedule
  */
 export declare function writeTask(task: RafCallback): void;
 /**
@@ -302,8 +279,6 @@ export declare function writeTask(task: RafCallback): void;
  * in the best moment to perform DOM reads without causing layout thrashing.
  *
  * For further information: https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing
- *
- * @param task the DOM-read to schedule
  */
 export declare function readTask(task: RafCallback): void;
 /**
@@ -442,57 +417,13 @@ interface HostAttributes {
     ref?: (el: HTMLElement | null) => void;
     [prop: string]: any;
 }
-/**
- * Utilities for working with functional Stencil components. An object
- * conforming to this interface is passed by the Stencil runtime as the third
- * argument to a functional component, allowing component authors to work with
- * features like children.
- *
- * The children of a functional component will be passed as the second
- * argument, so a functional component which uses these utils to transform its
- * children might look like the following:
- *
- * ```ts
- * export const AddClass: FunctionalComponent = (_, children, utils) => (
- *  utils.map(children, child => ({
- *    ...child,
- *    vattrs: {
- *      ...child.vattrs,
- *      class: `${child.vattrs.class} add-class`
- *    }
- *  }))
- * );
- * ```
- *
- * For more see the Stencil documentation, here:
- * https://stenciljs.com/docs/functional-components
- */
 export interface FunctionalUtilities {
-    /**
-     * Utility for reading the children of a functional component at runtime.
-     * Since the Stencil runtime uses a different interface for children it is
-     * not recommendeded to read the children directly, and is preferable to use
-     * this utility to, for instance, perform a side effect for each child.
-     */
     forEach: (children: VNode[], cb: (vnode: ChildNode, index: number, array: ChildNode[]) => void) => void;
-    /**
-     * Utility for transforming the children of a functional component. Given an
-     * array of children and a callback this will return a list of the results of
-     * passing each child to the supplied callback.
-     */
     map: (children: VNode[], cb: (vnode: ChildNode, index: number, array: ChildNode[]) => ChildNode) => VNode[];
 }
 export interface FunctionalComponent<T = {}> {
     (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[];
 }
-/**
- * A Child VDOM node
- *
- * This has most of the same properties as {@link VNode} but friendlier names
- * (i.e. `vtag` instead of `$tag$`, `vchildren` instead of `$children$`) in
- * order to provide a friendlier public interface for users of the
- * {@link FunctionalUtilities}).
- */
 export interface ChildNode {
     vtag?: string | number | Function;
     vkey?: string | number;
@@ -539,9 +470,6 @@ export declare function h(sel: any, children: Array<VNode | undefined | null>):
 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;
-/**
- * A virtual DOM node
- */
 export interface VNode {
     $flags$: number;
     $tag$: string | number | Function;

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/LICENSE.md

@@ -0,0 +1,27 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-present Drifty Co.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+-----------------------------------------
+Third-party components, software, and/or libraries (collectively, "components")
+are included under the licenses specified by their authors. For information
+about these third-party licenses, refer to the separate legal notices governing
+such components at NOTICE file at the top level of the package.

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/bin/stencil

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+'use strict';
+
+var minimumVersion = '12.10';
+var futureDeprecationMinVersion = '14.0';
+var recommendedVersion = '14.5';
+var currentVersion = process.versions.node;
+
+function isNodeLT(v) {
+  var check = v.split('.').map(Number);
+  var node = currentVersion.split('.').map(Number);
+  return node[0] < check[0] || (node[0] === check[0] && node[1] < check[1]);
+}
+
+if (isNodeLT(minimumVersion)) {
+  console.error(
+    '\nYour current version of Node is v' +
+      currentVersion +
+      ', however Stencil requires v' +
+      minimumVersion +
+      '.0 or greater. It is recommended to use an Active LTS version of Node (https://nodejs.org/en/about/releases/).\n'
+  );
+  process.exit(1);
+}
+
+if (isNodeLT(futureDeprecationMinVersion)) {
+  console.warn(
+    '\nIn an upcoming major release of Stencil, Node v' + recommendedVersion + '.0 or higher will be required.\n'
+  );
+} else if (isNodeLT(recommendedVersion)) {
+  console.warn(
+    '\nYour current version of Node is v' +
+      currentVersion +
+      ", however Stencil's recommendation is v" +
+      recommendedVersion +
+      '.0 or greater. Note that future versions of Stencil will eventually remove support for non-LTS Node versions and an Active LTS version is recommended (https://nodejs.org/en/about/releases/).\n'
+  );
+}
+
+var cli = require('../cli/index.cjs');
+var nodeApi = require('../sys/node/index.js');
+var nodeLogger = nodeApi.createNodeLogger({ process: process });
+var nodeSys = nodeApi.createNodeSys({ process: process, logger: nodeLogger });
+
+nodeApi.setupNodeProcess({ process: process, logger: nodeLogger });
+
+cli
+  .run({
+    args: process.argv.slice(2),
+    logger: nodeLogger,
+    sys: nodeSys,
+    checkVersion: nodeApi.checkVersion,
+  })
+  .catch(function (err) {
+    console.error('uncaught error', err);
+    process.exit(1);
+  });

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/cli/config-flags.d.ts

@@ -0,0 +1,122 @@
+import type { LogLevel, TaskCommand } from '../internal/index';
+/**
+ * All the Boolean options supported by the Stencil CLI
+ */
+export declare const BOOLEAN_CLI_FLAGS: readonly ["build", "cache", "checkVersion", "ci", "compare", "debug", "dev", "devtools", "docs", "e2e", "es5", "esm", "headless", "help", "log", "open", "prerender", "prerenderExternal", "prod", "profile", "serviceWorker", "screenshot", "serve", "skipNodeCheck", "spec", "ssr", "stats", "updateScreenshot", "verbose", "version", "watch", "all", "automock", "bail", "changedFilesWithAncestor", "clearCache", "clearMocks", "collectCoverage", "color", "colors", "coverage", "detectLeaks", "detectOpenHandles", "errorOnDeprecated", "expand", "findRelatedTests", "forceExit", "init", "injectGlobals", "json", "lastCommit", "listTests", "logHeapUsage", "noStackTrace", "notify", "onlyChanged", "onlyFailures", "passWithNoTests", "resetMocks", "resetModules", "restoreMocks", "runInBand", "runTestsByPath", "showConfig", "silent", "skipFilter", "testLocationInResults", "updateSnapshot", "useStderr", "watchAll", "watchman"];
+/**
+ * All the Number options supported by the Stencil CLI
+ */
+export declare const NUMBER_CLI_FLAGS: readonly ["port", "maxConcurrency", "testTimeout"];
+/**
+ * All the String options supported by the Stencil CLI
+ */
+export declare const STRING_CLI_FLAGS: readonly ["address", "config", "docsApi", "docsJson", "emulate", "root", "screenshotConnector", "cacheDirectory", "changedSince", "collectCoverageFrom", "coverageDirectory", "coverageThreshold", "env", "filter", "globalSetup", "globalTeardown", "globals", "haste", "moduleNameMapper", "notifyMode", "outputFile", "preset", "prettierPath", "resolver", "rootDir", "runner", "testEnvironment", "testEnvironmentOptions", "testFailureExitCode", "testNamePattern", "testResultsProcessor", "testRunner", "testSequencer", "testURL", "timers", "transform"];
+export declare const STRING_ARRAY_CLI_FLAGS: readonly ["collectCoverageOnlyFrom", "coveragePathIgnorePatterns", "coverageReporters", "moduleDirectories", "moduleFileExtensions", "modulePathIgnorePatterns", "modulePaths", "projects", "reporters", "roots", "selectProjects", "setupFiles", "setupFilesAfterEnv", "snapshotSerializers", "testMatch", "testPathIgnorePatterns", "testPathPattern", "testRegex", "transformIgnorePatterns", "unmockedModulePathPatterns", "watchPathIgnorePatterns"];
+/**
+ * All the CLI arguments which may have string or number values
+ *
+ * `maxWorkers` is an argument which is used both by Stencil _and_ by Jest,
+ * which means that we need to support parsing both string and number values.
+ */
+export declare const STRING_NUMBER_CLI_FLAGS: readonly ["maxWorkers"];
+/**
+ * All the LogLevel-type options supported by the Stencil CLI
+ *
+ * This is a bit silly since there's only one such argument atm,
+ * but this approach lets us make sure that we're handling all
+ * our arguments in a type-safe way.
+ */
+export declare const LOG_LEVEL_CLI_FLAGS: readonly ["logLevel"];
+/**
+ * A type which gives the members of a `ReadonlyArray<string>` as
+ * an enum-like type which can be used for e.g. keys in a `Record`
+ * (as in the `AliasMap` type below)
+ */
+type ArrayValuesAsUnion<T extends ReadonlyArray<string>> = T[number];
+export type BooleanCLIFlag = ArrayValuesAsUnion<typeof BOOLEAN_CLI_FLAGS>;
+export type StringCLIFlag = ArrayValuesAsUnion<typeof STRING_CLI_FLAGS>;
+export type StringArrayCLIFlag = ArrayValuesAsUnion<typeof STRING_ARRAY_CLI_FLAGS>;
+export type NumberCLIFlag = ArrayValuesAsUnion<typeof NUMBER_CLI_FLAGS>;
+export type StringNumberCLIFlag = ArrayValuesAsUnion<typeof STRING_NUMBER_CLI_FLAGS>;
+export type LogCLIFlag = ArrayValuesAsUnion<typeof LOG_LEVEL_CLI_FLAGS>;
+export type KnownCLIFlag = BooleanCLIFlag | StringCLIFlag | StringArrayCLIFlag | NumberCLIFlag | StringNumberCLIFlag | LogCLIFlag;
+type AliasMap = Partial<Record<string, KnownCLIFlag>>;
+/**
+ * For a small subset of CLI options we support a short alias e.g. `'h'` for `'help'`
+ */
+export declare const CLI_FLAG_ALIASES: AliasMap;
+/**
+ * A regular expression which can be used to match a CLI flag for one of our
+ * short aliases.
+ */
+export declare const CLI_FLAG_REGEX: RegExp;
+/**
+ * Given two types `K` and `T` where `K` extends `ReadonlyArray<string>`,
+ * construct a type which maps the strings in `K` as keys to values of type `T`.
+ *
+ * Because we use types derived this way to construct an interface (`ConfigFlags`)
+ * for which we want optional keys, we make all the properties optional (w/ `'?'`)
+ * and possibly null.
+ */
+type ObjectFromKeys<K extends ReadonlyArray<string>, T> = {
+    [key in K[number]]?: T | null;
+};
+/**
+ * Type containing the possible Boolean configuration flags, to be included
+ * in ConfigFlags, below
+ */
+type BooleanConfigFlags = ObjectFromKeys<typeof BOOLEAN_CLI_FLAGS, boolean>;
+/**
+ * Type containing the possible String configuration flags, to be included
+ * in ConfigFlags, below
+ */
+type StringConfigFlags = ObjectFromKeys<typeof STRING_CLI_FLAGS, string>;
+/**
+ * Type containing the possible String Array configuration flags. This is
+ * one of the 'constituent types' for `ConfigFlags`.
+ */
+type StringArrayConfigFlags = ObjectFromKeys<typeof STRING_ARRAY_CLI_FLAGS, string[]>;
+/**
+ * Type containing the possible numeric configuration flags, to be included
+ * in ConfigFlags, below
+ */
+type NumberConfigFlags = ObjectFromKeys<typeof NUMBER_CLI_FLAGS, number>;
+/**
+ * Type containing the configuration flags which may be set to either string
+ * or number values.
+ */
+type StringNumberConfigFlags = ObjectFromKeys<typeof STRING_NUMBER_CLI_FLAGS, string | number>;
+/**
+ * Type containing the possible LogLevel configuration flags, to be included
+ * in ConfigFlags, below
+ */
+type LogLevelFlags = ObjectFromKeys<typeof LOG_LEVEL_CLI_FLAGS, LogLevel>;
+/**
+ * The configuration flags which can be set by the user on the command line.
+ * This interface captures both known arguments (which are enumerated and then
+ * parsed according to their types) and unknown arguments which the user may
+ * pass at the CLI.
+ *
+ * Note that this interface is constructed by extending `BooleanConfigFlags`,
+ * `StringConfigFlags`, etc. These types are in turn constructed from types
+ * extending `ReadonlyArray<string>` which we declare in another module. This
+ * allows us to record our known CLI arguments in one place, using a
+ * `ReadonlyArray<string>` to get both a type-level representation of what CLI
+ * options we support and a runtime list of strings which can be used to match
+ * on actual flags passed by the user.
+ */
+export interface ConfigFlags extends BooleanConfigFlags, StringConfigFlags, StringArrayConfigFlags, NumberConfigFlags, StringNumberConfigFlags, LogLevelFlags {
+    task: TaskCommand | null;
+    args: string[];
+    knownArgs: string[];
+    unknownArgs: string[];
+}
+/**
+ * Helper function for initializing a `ConfigFlags` object. Provide any overrides
+ * for default values and off you go!
+ *
+ * @param init an object with any overrides for default values
+ * @returns a complete CLI flag object
+ */
+export declare const createConfigFlags: (init?: Partial<ConfigFlags>) => ConfigFlags;
+export {};