@postnord/pn-marketweb-components 2.1.9 → 2.2.0

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/compiler/sys/in-memory-fs.d.ts

@@ -0,0 +1,218 @@
+import type * as d from '../../internal/index';
+/**
+ * An in-memory FS which proxies the underlying OS filesystem using a simple
+ * in-memory cache. FS writes can accumulate on the in-memory system, using an
+ * API similar to Node.js' `"fs"` module, and then be committed to disk as a
+ * unit.
+ *
+ * Files written to the in-memory system can be edited, deleted, and so on.
+ * This allows the compiler to proceed freely as if it is modifying the
+ * filesystem, modifying the world in whatever way suits it, while deferring
+ * actual FS writes until the end of the compilation process, making actual
+ * changes to the filesystem on disk contingent on an error-free build or any
+ * other condition.
+ *
+ * Usage example:
+ *
+ * ```ts
+ * // create an in-memory FS
+ * const sys = createSystem();
+ * const inMemoryFs = createInMemoryFs(sys);
+ *
+ * // do a few fs operations
+ * await inMemoryFs.writeFile("path/to/file.js", 'console.log("hey!");')
+ * await inMemoryFs.remove("path/to/another_file.ts");
+ *
+ * // commit the results to disk
+ * const commitStats = await inMemoryFs.commit();
+ * ```
+ *
+ * In the above example the write operation and the delete operation (w/
+ * `.remove`) are both queued in the in-memory proxy but not committed to
+ * disk until the `.commit` method is called.
+ */
+export type InMemoryFileSystem = ReturnType<typeof createInMemoryFs>;
+/**
+ * A node in the in-memory file system. This may represent a file or
+ * a directory, and pending copy, write, and delete operations may be stored
+ * on it.
+ */
+export interface FsItem {
+    fileText: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs: number;
+    exists: boolean;
+    queueCopyFileToDest: string;
+    queueWriteToDisk: boolean;
+    queueDeleteFromDisk?: boolean;
+    useCache: boolean;
+}
+/**
+ * Storage format for the in-memory cache used to proxy the OS filesystem.
+ *
+ * Filesystem paths (of type `string`) are mapped to objects satisfying the
+ * `FsItem` interface.
+ */
+export type FsItems = Map<string, FsItem>;
+/**
+ * Options supported by write methods on the in-memory filesystem.
+ */
+export interface FsWriteOptions {
+    inMemoryOnly?: boolean;
+    clearFileCache?: boolean;
+    immediateWrite?: boolean;
+    useCache?: boolean;
+    /**
+     * An optional tag for the current output target for which this file is being
+     * written.
+     */
+    outputTargetType?: string;
+}
+/**
+ * Results from a write operation on the in-memory filesystem.
+ */
+export interface FsWriteResults {
+    changedContent: boolean;
+    queuedWrite: boolean;
+    ignored: boolean;
+}
+/**
+ * Options supported by read methods on the in-memory filesystem.
+ */
+export interface FsReadOptions {
+    useCache?: boolean;
+    setHash?: boolean;
+}
+/**
+ * Options supported by the readdir option on the in-memory filesystem.
+ */
+interface FsReaddirOptions {
+    inMemoryOnly?: boolean;
+    recursive?: boolean;
+    /**
+     * Directory names to exclude. Just the basename,
+     * not the entire path. Basically for "node_modules".
+     */
+    excludeDirNames?: string[];
+    /**
+     * Extensions we know we can avoid. Each extension
+     * should include the `.` so that we can test for both
+     * `.d.ts.` and `.ts`. If `excludeExtensions` isn't provided it
+     * doesn't try to exclude anything. This only checks against
+     * the filename, not directory names when recursive.
+     */
+    excludeExtensions?: string[];
+}
+/**
+ * A result from a directory read operation
+ */
+interface FsReaddirItem {
+    absPath: string;
+    relPath: string;
+    isDirectory: boolean;
+    isFile: boolean;
+}
+/**
+ * Information about a file in the in-memory filesystem.
+ */
+interface FsStat {
+    exists: boolean;
+    isFile: boolean;
+    isDirectory: boolean;
+    size: number;
+}
+/**
+ * Create an in-memory FS which proxies the underlying OS filesystem using an
+ * in-memory cache. FS writes can accumulate on the in-memory system, using an
+ * API similar to Node.js' `"fs"` module, and then be committed to disk as a
+ * unit.
+ *
+ * Files written to the in-memory system can be edited, deleted, and so on.
+ * This allows the compiler to proceed freely as if it is modifying the
+ * filesystem, modifying the world in whatever way suits it, while deferring
+ * actual FS writes until the end of the compilation process, making actual
+ * changes to the filesystem on disk contingent on an error-free build or any
+ * other condition.
+ *
+ * @param sys a compiler system object
+ * @returns an in-memory filesystem interface
+ */
+export declare const createInMemoryFs: (sys: d.CompilerSystem) => {
+    access: (filePath: string) => Promise<boolean>;
+    accessSync: (filePath: string) => boolean;
+    cancelDeleteDirectoriesFromDisk: (dirPaths: string[]) => void;
+    cancelDeleteFilesFromDisk: (filePaths: string[]) => void;
+    clearCache: () => void;
+    clearDirCache: (dirPath: string) => void;
+    clearFileCache: (filePath: string) => void;
+    commit: () => Promise<FsCommitResults>;
+    copyFile: (src: string, dest: string) => Promise<void>;
+    emptyDirs: (dirs: string[]) => Promise<void>;
+    getBuildOutputs: () => d.BuildOutput[];
+    getItem: (itemPath: string) => FsItem;
+    getMemoryStats: () => string;
+    readFile: (filePath: string, opts?: FsReadOptions) => Promise<string>;
+    readFileSync: (filePath: string, opts?: FsReadOptions) => string;
+    readdir: (dirPath: string, opts?: FsReaddirOptions) => Promise<FsReaddirItem[]>;
+    remove: (itemPath: string) => Promise<void>;
+    stat: (itemPath: string) => Promise<FsStat>;
+    statSync: (itemPath: string) => FsStat;
+    sys: d.CompilerSystem;
+    writeFile: (filePath: string, content: string, opts?: FsWriteOptions) => Promise<FsWriteResults>;
+    writeFiles: (files: {
+        [filePath: string]: string;
+    } | Map<string, string>, opts?: FsWriteOptions) => Promise<FsWriteResults[]>;
+};
+/**
+ * The information needed to carry out a file copy operation.
+ *
+ * `[ source, destination ]`
+ */
+type FileCopyTuple = [string, string];
+/**
+ * Collected instructions for all pending filesystem operations saved
+ * to the in-memory filesystem.
+ */
+interface FsCommitInstructions {
+    filesToDelete: string[];
+    filesToWrite: string[];
+    /**
+     * Files queued for copy operations are stored as an array of `[source, dest]`
+     * tuples.
+     */
+    filesToCopy: FileCopyTuple[];
+    dirsToDelete: string[];
+    dirsToEnsure: string[];
+}
+/**
+ * Results from committing pending filesystem operations
+ */
+interface FsCommitResults {
+    filesCopied: FileCopyTuple[];
+    filesWritten: string[];
+    filesDeleted: string[];
+    dirsDeleted: string[];
+    dirsAdded: string[];
+}
+/**
+ * Given the current state of the in-memory proxy filesystem, collect all of
+ * the changes that need to be made in order to commit the currently-pending
+ * operations (e.g. write, copy, delete) to the OS filesystem.
+ *
+ * @param items the storage data structure for the in-memory FS cache
+ * @returns a collection of all the operations that need to be done
+ */
+export declare const getCommitInstructions: (items: FsItems) => FsCommitInstructions;
+/**
+ * Check whether a given filepath should be ignored
+ *
+ * We have a little ignore list, and we just check whether the
+ * filepath ends with any of the strings on the ignore list.
+ *
+ * @param filePath the filepath to check!
+ * @returns whether we should ignore it or not
+ */
+export declare const shouldIgnore: (filePath: string) => boolean;
+export {};

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

@@ -0,0 +1,32 @@
+import type { TranspileOptions, TranspileResults } from '../internal/index';
+/**
+ * The `transpile()` function inputs source code as a string, with various options
+ * within the second argument. The function is stateless and returns a `Promise` of the
+ * results, including diagnostics and the transpiled code. The `transpile()` function
+ * does not handle any bundling, minifying, or precompiling any CSS preprocessing like
+ * Sass or Less. The `transpileSync()` equivalent is available so the same function
+ * it can be called synchronously. However, TypeScript must be already loaded within
+ * the global for it to work, where as the async `transpile()` function will load
+ * TypeScript automatically.
+ *
+ * Since TypeScript is used, the source code will transpile from TypeScript to JavaScript,
+ * and does not require Babel presets. Additionally, the results includes an `imports`
+ * array of all the import paths found in the source file. The transpile options can be
+ * used to set the `module` format, such as `cjs`, and JavaScript `target` version, such
+ * as `es2017`.
+ *
+ * @param code the code to transpile
+ * @param opts options for the transpilation process
+ * @returns a Promise wrapping the results of the transpilation
+ */
+export declare const transpile: (code: string, opts?: TranspileOptions) => Promise<TranspileResults>;
+/**
+ * Synchronous equivalent of the `transpile()` function. When used in a browser
+ * environment, TypeScript must already be available globally, where as the async
+ * `transpile()` function will load TypeScript automatically.
+ *
+ * @param code the code to transpile
+ * @param opts options for the transpilation process
+ * @returns the results of the transpilation
+ */
+export declare const transpileSync: (code: string, opts?: TranspileOptions) => TranspileResults;

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

@@ -0,0 +1,120 @@
+{
+  "dependencies": [
+    {
+      "name": "@stencil/core",
+      "version": "2.22.2",
+      "main": "compiler/stencil.js",
+      "resources": [
+        "package.json",
+        "compiler/lib.d.ts",
+        "compiler/lib.dom.d.ts",
+        "compiler/lib.dom.iterable.d.ts",
+        "compiler/lib.es2015.collection.d.ts",
+        "compiler/lib.es2015.core.d.ts",
+        "compiler/lib.es2015.d.ts",
+        "compiler/lib.es2015.generator.d.ts",
+        "compiler/lib.es2015.iterable.d.ts",
+        "compiler/lib.es2015.promise.d.ts",
+        "compiler/lib.es2015.proxy.d.ts",
+        "compiler/lib.es2015.reflect.d.ts",
+        "compiler/lib.es2015.symbol.d.ts",
+        "compiler/lib.es2015.symbol.wellknown.d.ts",
+        "compiler/lib.es2016.array.include.d.ts",
+        "compiler/lib.es2016.d.ts",
+        "compiler/lib.es2016.full.d.ts",
+        "compiler/lib.es2017.d.ts",
+        "compiler/lib.es2017.full.d.ts",
+        "compiler/lib.es2017.intl.d.ts",
+        "compiler/lib.es2017.object.d.ts",
+        "compiler/lib.es2017.sharedmemory.d.ts",
+        "compiler/lib.es2017.string.d.ts",
+        "compiler/lib.es2017.typedarrays.d.ts",
+        "compiler/lib.es2018.asyncgenerator.d.ts",
+        "compiler/lib.es2018.asynciterable.d.ts",
+        "compiler/lib.es2018.d.ts",
+        "compiler/lib.es2018.full.d.ts",
+        "compiler/lib.es2018.intl.d.ts",
+        "compiler/lib.es2018.promise.d.ts",
+        "compiler/lib.es2018.regexp.d.ts",
+        "compiler/lib.es2019.array.d.ts",
+        "compiler/lib.es2019.d.ts",
+        "compiler/lib.es2019.full.d.ts",
+        "compiler/lib.es2019.intl.d.ts",
+        "compiler/lib.es2019.object.d.ts",
+        "compiler/lib.es2019.string.d.ts",
+        "compiler/lib.es2019.symbol.d.ts",
+        "compiler/lib.es2020.bigint.d.ts",
+        "compiler/lib.es2020.d.ts",
+        "compiler/lib.es2020.date.d.ts",
+        "compiler/lib.es2020.full.d.ts",
+        "compiler/lib.es2020.intl.d.ts",
+        "compiler/lib.es2020.number.d.ts",
+        "compiler/lib.es2020.promise.d.ts",
+        "compiler/lib.es2020.sharedmemory.d.ts",
+        "compiler/lib.es2020.string.d.ts",
+        "compiler/lib.es2020.symbol.wellknown.d.ts",
+        "compiler/lib.es2021.d.ts",
+        "compiler/lib.es2021.full.d.ts",
+        "compiler/lib.es2021.intl.d.ts",
+        "compiler/lib.es2021.promise.d.ts",
+        "compiler/lib.es2021.string.d.ts",
+        "compiler/lib.es2021.weakref.d.ts",
+        "compiler/lib.es2022.array.d.ts",
+        "compiler/lib.es2022.d.ts",
+        "compiler/lib.es2022.error.d.ts",
+        "compiler/lib.es2022.full.d.ts",
+        "compiler/lib.es2022.intl.d.ts",
+        "compiler/lib.es2022.object.d.ts",
+        "compiler/lib.es2022.sharedmemory.d.ts",
+        "compiler/lib.es2022.string.d.ts",
+        "compiler/lib.es5.d.ts",
+        "compiler/lib.es6.d.ts",
+        "compiler/lib.esnext.d.ts",
+        "compiler/lib.esnext.full.d.ts",
+        "compiler/lib.esnext.intl.d.ts",
+        "compiler/lib.esnext.promise.d.ts",
+        "compiler/lib.esnext.string.d.ts",
+        "compiler/lib.esnext.weakref.d.ts",
+        "compiler/lib.scripthost.d.ts",
+        "compiler/lib.webworker.d.ts",
+        "compiler/lib.webworker.importscripts.d.ts",
+        "compiler/lib.webworker.iterable.d.ts",
+        "internal/index.d.ts",
+        "internal/index.js",
+        "internal/package.json",
+        "internal/stencil-ext-modules.d.ts",
+        "internal/stencil-private.d.ts",
+        "internal/stencil-public-compiler.d.ts",
+        "internal/stencil-public-docs.d.ts",
+        "internal/stencil-public-runtime.d.ts",
+        "mock-doc/index.js",
+        "mock-doc/package.json",
+        "internal/client/css-shim.js",
+        "internal/client/dom.js",
+        "internal/client/index.js",
+        "internal/client/package.json",
+        "internal/client/patch-browser.js",
+        "internal/client/patch-esm.js",
+        "internal/client/shadow-css.js",
+        "internal/hydrate/index.js",
+        "internal/hydrate/package.json",
+        "internal/hydrate/runner.js",
+        "internal/hydrate/shadow-css.js",
+        "internal/stencil-core/index.d.ts",
+        "internal/stencil-core/index.js"
+      ]
+    },
+    {
+      "name": "rollup",
+      "main": "dist/es/rollup.browser.js"
+    },
+    {
+      "name": "terser",
+      "main": "dist/bundle.min.js"
+    },
+    {
+      "name": "typescript",
+      "main": "lib/typescript.js"
+    }
+  ]
+}

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/app-error.d.ts

@@ -0,0 +1,18 @@
+interface AppErrorData {
+    window: Window;
+    buildResults: any;
+    openInEditor?: OpenInEditorCallback;
+}
+type OpenInEditorCallback = (data: {
+    file: string;
+    line: number;
+    column: number;
+}) => void;
+export declare const appError: (data: AppErrorData) => {
+    diagnostics: any[];
+    status: string;
+};
+export declare const clearAppErrorModal: (data: {
+    window: Window;
+}) => void;
+export {};

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/events.d.ts

@@ -0,0 +1,6 @@
+export declare const emitBuildLog: (win: Window, buildLog: any) => void;
+export declare const emitBuildResults: (win: Window, buildResults: any) => void;
+export declare const emitBuildStatus: (win: Window, buildStatus: string) => void;
+export declare const onBuildLog: (win: Window, cb: (buildLog: any) => void) => void;
+export declare const onBuildResults: (win: Window, cb: (buildResults: any) => void) => void;
+export declare const onBuildStatus: (win: Window, cb: (buildStatus: string) => void) => void;

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-components.d.ts

@@ -0,0 +1 @@
+export declare const hmrComponents: (elm: Element, versionId: string, hmrTagNames: string[]) => string[];

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-external-styles.d.ts

@@ -0,0 +1 @@
+export declare const hmrExternalStyles: (elm: Element, versionId: string, cssFileNames: string[]) => string[];

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-images.d.ts

@@ -0,0 +1 @@
+export declare const hmrImages: (win: Window, doc: Document, versionId: string, imageFileNames: string[]) => string[];

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-inline-styles.d.ts

@@ -0,0 +1 @@
+export declare const hmrInlineStyles: (elm: Element, versionId: string, stylesUpdatedData: any[]) => any[];

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-util.d.ts

@@ -0,0 +1,9 @@
+export declare const getHmrHref: (versionId: string, fileName: string, testUrl: string) => string;
+export declare const setQueryString: (url: string, qsKey: string, qsValue: string) => string;
+export declare const setHmrQueryString: (url: string, versionId: string) => string;
+export declare const updateCssUrlValue: (versionId: string, fileName: string, oldCss: string) => string;
+export declare const isLinkStylesheet: (elm: Element) => boolean;
+export declare const isTemplate: (elm: Element) => boolean;
+export declare const setHmrAttr: (elm: Element, versionId: string) => void;
+export declare const hasShadowRoot: (elm: Element) => boolean;
+export declare const isElement: (elm: Element) => boolean;

package/umd/modules/@postnord/web-components/node_modules/@stencil/core/dev-server/client/hmr-window.d.ts

@@ -0,0 +1,10 @@
+export declare const hmrWindow: (data: {
+    window: Window;
+    hmr: any;
+}) => {
+    updatedComponents: string[];
+    updatedExternalStyles: string[];
+    updatedInlineStyles: string[];
+    updatedImages: string[];
+    versionId: string;
+};

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

@@ -0,0 +1,6 @@
+export { appError, clearAppErrorModal } from './app-error';
+export { emitBuildLog, emitBuildResults, emitBuildStatus, onBuildLog, onBuildResults, onBuildStatus } from './events';
+export { hmrWindow } from './hmr-window';
+export { logBuild, logDiagnostic, logDisabled, logReload, logWarn } from './logger';
+export { initBuildProgress } from './progress';
+export { initBuildStatus } from './status';