@genesislcap/foundation-progress-overlay 10.3.1 → 11.3.1

package/dist/dts/components/components.d.ts

@@ -0,0 +1,7 @@
+declare function loadZeroDesignSystem(): Promise<any>;
+type LoadRemotesOptions = {};
+declare function loadRemotes(options: LoadRemotesOptions): Promise<{
+    ZeroDesignSystem: any;
+}>;
+export { LoadRemotesOptions, loadRemotes, loadZeroDesignSystem };
+//# sourceMappingURL=components.d.ts.map

package/dist/dts/components/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/components/components.ts"],"names":[],"mappings":"AAwBA,iBAAe,oBAAoB,iBAWlC;AAED,KAAK,kBAAkB,GAAG,EAAE,CAAC;AAE7B,iBAAe,WAAW,CAAC,OAAO,EAAE,kBAAkB;;GAKrD;AAMD,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/dts/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/dts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/dts/index.federated.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.federated.d.ts.map

package/dist/dts/index.federated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.federated.d.ts","sourceRoot":"","sources":["../../src/index.federated.ts"],"names":[],"mappings":""}

package/dist/dts/main/index.d.ts

@@ -0,0 +1,3 @@
+export * from './main.template';
+export * from './main';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,QAAQ,CAAC"}

package/dist/dts/main/main.d.ts

@@ -0,0 +1,335 @@
+import { FASTElement } from '@microsoft/fast-element';
+declare const MainApplication_base: (new (...args: any[]) => {
+    pendingCount: number;
+    resolvedCount: number;
+    hasPendingChildren: boolean;
+    readonly progress: number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onPendingState({ detail }: import("@genesislcap/foundation-utils").PendingStateEvent): Promise<void>;
+    readonly $fastController: import("@microsoft/fast-element").Controller;
+    $emit(type: string, detail?: any, options?: Omit<CustomEventInit<any>, "detail">): boolean | void;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    accessKey: string;
+    readonly accessKeyLabel: string;
+    autocapitalize: string;
+    dir: string;
+    draggable: boolean;
+    hidden: boolean;
+    inert: boolean;
+    innerText: string;
+    lang: string;
+    readonly offsetHeight: number;
+    readonly offsetLeft: number;
+    readonly offsetParent: Element;
+    readonly offsetTop: number;
+    readonly offsetWidth: number;
+    outerText: string;
+    spellcheck: boolean;
+    title: string;
+    translate: boolean;
+    attachInternals(): ElementInternals;
+    click(): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K_1 extends keyof HTMLElementEventMap>(type: K_1, listener: (this: HTMLElement, ev: HTMLElementEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    readonly attributes: NamedNodeMap;
+    readonly classList: DOMTokenList;
+    className: string;
+    readonly clientHeight: number;
+    readonly clientLeft: number;
+    readonly clientTop: number;
+    readonly clientWidth: number;
+    id: string;
+    readonly localName: string;
+    readonly namespaceURI: string;
+    onfullscreenchange: (this: Element, ev: Event) => any;
+    onfullscreenerror: (this: Element, ev: Event) => any;
+    outerHTML: string;
+    readonly ownerDocument: Document;
+    readonly part: DOMTokenList;
+    readonly prefix: string;
+    readonly scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    readonly scrollWidth: number;
+    readonly shadowRoot: ShadowRoot;
+    slot: string;
+    readonly tagName: string;
+    attachShadow(init: ShadowRootInit): ShadowRoot;
+    closest<K_2 extends keyof HTMLElementTagNameMap>(selector: K_2): HTMLElementTagNameMap[K_2];
+    closest<K_3 extends keyof SVGElementTagNameMap>(selector: K_3): SVGElementTagNameMap[K_3];
+    closest<E extends Element = Element>(selectors: string): E;
+    getAttribute(qualifiedName: string): string;
+    getAttributeNS(namespace: string, localName: string): string;
+    getAttributeNames(): string[];
+    getAttributeNode(qualifiedName: string): Attr;
+    getAttributeNodeNS(namespace: string, localName: string): Attr;
+    getBoundingClientRect(): DOMRect;
+    getClientRects(): DOMRectList;
+    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
+    getElementsByTagName<K_4 extends keyof HTMLElementTagNameMap>(qualifiedName: K_4): HTMLCollectionOf<HTMLElementTagNameMap[K_4]>;
+    getElementsByTagName<K_5 extends keyof SVGElementTagNameMap>(qualifiedName: K_5): HTMLCollectionOf<SVGElementTagNameMap[K_5]>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+    getElementsByTagNameNS(namespace: string, localName: string): HTMLCollectionOf<Element>;
+    hasAttribute(qualifiedName: string): boolean;
+    hasAttributeNS(namespace: string, localName: string): boolean;
+    hasAttributes(): boolean;
+    hasPointerCapture(pointerId: number): boolean;
+    insertAdjacentElement(where: InsertPosition, element: Element): Element;
+    insertAdjacentHTML(position: InsertPosition, text: string): void;
+    insertAdjacentText(where: InsertPosition, data: string): void;
+    matches(selectors: string): boolean;
+    releasePointerCapture(pointerId: number): void;
+    removeAttribute(qualifiedName: string): void;
+    removeAttributeNS(namespace: string, localName: string): void;
+    removeAttributeNode(attr: Attr): Attr;
+    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestPointerLock(): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    setAttribute(qualifiedName: string, value: string): void;
+    setAttributeNS(namespace: string, qualifiedName: string, value: string): void;
+    setAttributeNode(attr: Attr): Attr;
+    setAttributeNodeNS(attr: Attr): Attr;
+    setPointerCapture(pointerId: number): void;
+    toggleAttribute(qualifiedName: string, force?: boolean): boolean;
+    webkitMatchesSelector(selectors: string): boolean;
+    readonly baseURI: string;
+    readonly childNodes: NodeListOf<ChildNode>;
+    readonly firstChild: ChildNode;
+    readonly isConnected: boolean;
+    readonly lastChild: ChildNode;
+    readonly nextSibling: ChildNode;
+    readonly nodeName: string;
+    readonly nodeType: number;
+    nodeValue: string;
+    readonly parentElement: HTMLElement;
+    readonly parentNode: ParentNode;
+    readonly previousSibling: ChildNode;
+    textContent: string;
+    appendChild<T extends Node>(node: T): T;
+    cloneNode(deep?: boolean): Node;
+    compareDocumentPosition(other: Node): number;
+    contains(other: Node): boolean;
+    getRootNode(options?: GetRootNodeOptions): Node;
+    hasChildNodes(): boolean;
+    insertBefore<T_1 extends Node>(node: T_1, child: Node): T_1;
+    isDefaultNamespace(namespace: string): boolean;
+    isEqualNode(otherNode: Node): boolean;
+    isSameNode(otherNode: Node): boolean;
+    lookupNamespaceURI(prefix: string): string;
+    lookupPrefix(namespace: string): string;
+    normalize(): void;
+    removeChild<T_2 extends Node>(child: T_2): T_2;
+    replaceChild<T_3 extends Node>(node: Node, child: T_3): T_3;
+    readonly ATTRIBUTE_NODE: number;
+    readonly CDATA_SECTION_NODE: number;
+    readonly COMMENT_NODE: number;
+    readonly DOCUMENT_FRAGMENT_NODE: number;
+    readonly DOCUMENT_NODE: number;
+    readonly DOCUMENT_POSITION_CONTAINED_BY: number;
+    readonly DOCUMENT_POSITION_CONTAINS: number;
+    readonly DOCUMENT_POSITION_DISCONNECTED: number;
+    readonly DOCUMENT_POSITION_FOLLOWING: number;
+    readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+    readonly DOCUMENT_POSITION_PRECEDING: number;
+    readonly DOCUMENT_TYPE_NODE: number;
+    readonly ELEMENT_NODE: number;
+    readonly ENTITY_NODE: number;
+    readonly ENTITY_REFERENCE_NODE: number;
+    readonly NOTATION_NODE: number;
+    readonly PROCESSING_INSTRUCTION_NODE: number;
+    readonly TEXT_NODE: number;
+    dispatchEvent(event: Event): boolean;
+    ariaAtomic: string;
+    ariaAutoComplete: string;
+    ariaBusy: string;
+    ariaChecked: string;
+    ariaColCount: string;
+    ariaColIndex: string;
+    ariaColIndexText: string;
+    ariaColSpan: string;
+    ariaCurrent: string;
+    ariaDisabled: string;
+    ariaExpanded: string;
+    ariaHasPopup: string;
+    ariaHidden: string;
+    ariaInvalid: string;
+    ariaKeyShortcuts: string;
+    ariaLabel: string;
+    ariaLevel: string;
+    ariaLive: string;
+    ariaModal: string;
+    ariaMultiLine: string;
+    ariaMultiSelectable: string;
+    ariaOrientation: string;
+    ariaPlaceholder: string;
+    ariaPosInSet: string;
+    ariaPressed: string;
+    ariaReadOnly: string;
+    ariaRequired: string;
+    ariaRoleDescription: string;
+    ariaRowCount: string;
+    ariaRowIndex: string;
+    ariaRowIndexText: string;
+    ariaRowSpan: string;
+    ariaSelected: string;
+    ariaSetSize: string;
+    ariaSort: string;
+    ariaValueMax: string;
+    ariaValueMin: string;
+    ariaValueNow: string;
+    ariaValueText: string;
+    role: string;
+    animate(keyframes: PropertyIndexedKeyframes | Keyframe[], options?: number | KeyframeAnimationOptions): Animation;
+    getAnimations(options?: GetAnimationsOptions): Animation[];
+    after(...nodes: (string | Node)[]): void;
+    before(...nodes: (string | Node)[]): void;
+    remove(): void;
+    replaceWith(...nodes: (string | Node)[]): void;
+    innerHTML: string;
+    readonly nextElementSibling: Element;
+    readonly previousElementSibling: Element;
+    readonly childElementCount: number;
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    append(...nodes: (string | Node)[]): void;
+    prepend(...nodes: (string | Node)[]): void;
+    querySelector<K_6 extends keyof HTMLElementTagNameMap>(selectors: K_6): HTMLElementTagNameMap[K_6];
+    querySelector<K_7 extends keyof SVGElementTagNameMap>(selectors: K_7): SVGElementTagNameMap[K_7];
+    querySelector<E_1 extends Element = Element>(selectors: string): E_1;
+    querySelectorAll<K_8 extends keyof HTMLElementTagNameMap>(selectors: K_8): NodeListOf<HTMLElementTagNameMap[K_8]>;
+    querySelectorAll<K_9 extends keyof SVGElementTagNameMap>(selectors: K_9): NodeListOf<SVGElementTagNameMap[K_9]>;
+    querySelectorAll<E_2 extends Element = Element>(selectors: string): NodeListOf<E_2>;
+    replaceChildren(...nodes: (string | Node)[]): void;
+    readonly assignedSlot: HTMLSlotElement;
+    oncopy: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    oncut: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    onpaste: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    readonly style: CSSStyleDeclaration;
+    contentEditable: string;
+    enterKeyHint: string;
+    inputMode: string;
+    readonly isContentEditable: boolean;
+    onabort: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onanimationcancel: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationend: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationiteration: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationstart: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onauxclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onbeforeinput: (this: GlobalEventHandlers, ev: InputEvent) => any;
+    onblur: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    oncancel: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplay: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplaythrough: (this: GlobalEventHandlers, ev: Event) => any;
+    onchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onclose: (this: GlobalEventHandlers, ev: Event) => any;
+    oncontextmenu: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    oncuechange: (this: GlobalEventHandlers, ev: Event) => any;
+    ondblclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    ondrag: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragend: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragenter: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragleave: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragover: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragstart: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondrop: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondurationchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onemptied: (this: GlobalEventHandlers, ev: Event) => any;
+    onended: (this: GlobalEventHandlers, ev: Event) => any;
+    onerror: OnErrorEventHandlerNonNull;
+    onfocus: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    onformdata: (this: GlobalEventHandlers, ev: FormDataEvent) => any;
+    ongotpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    oninput: (this: GlobalEventHandlers, ev: Event) => any;
+    oninvalid: (this: GlobalEventHandlers, ev: Event) => any;
+    onkeydown: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeypress: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeyup: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onload: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadeddata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadedmetadata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onlostpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onmousedown: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseenter: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseleave: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmousemove: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseout: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseover: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseup: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onpause: (this: GlobalEventHandlers, ev: Event) => any;
+    onplay: (this: GlobalEventHandlers, ev: Event) => any;
+    onplaying: (this: GlobalEventHandlers, ev: Event) => any;
+    onpointercancel: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerdown: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerenter: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerleave: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointermove: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerout: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerover: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerup: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onprogress: (this: GlobalEventHandlers, ev: ProgressEvent<EventTarget>) => any;
+    onratechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onreset: (this: GlobalEventHandlers, ev: Event) => any;
+    onresize: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onscroll: (this: GlobalEventHandlers, ev: Event) => any;
+    onsecuritypolicyviolation: (this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any;
+    onseeked: (this: GlobalEventHandlers, ev: Event) => any;
+    onseeking: (this: GlobalEventHandlers, ev: Event) => any;
+    onselect: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectionchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onslotchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onstalled: (this: GlobalEventHandlers, ev: Event) => any;
+    onsubmit: (this: GlobalEventHandlers, ev: SubmitEvent) => any;
+    onsuspend: (this: GlobalEventHandlers, ev: Event) => any;
+    ontimeupdate: (this: GlobalEventHandlers, ev: Event) => any;
+    ontoggle: (this: GlobalEventHandlers, ev: Event) => any;
+    ontouchcancel?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchend?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchmove?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchstart?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontransitioncancel: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionend: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionrun: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionstart: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    onvolumechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onwaiting: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationiteration: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkittransitionend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwheel: (this: GlobalEventHandlers, ev: WheelEvent) => any;
+    autofocus: boolean;
+    readonly dataset: DOMStringMap;
+    nonce?: string;
+    tabIndex: number;
+    blur(): void;
+    focus(options?: FocusOptions): void;
+}) & (new () => HTMLElement & FASTElement) & {
+    from<TBase extends {
+        new (): HTMLElement;
+        prototype: HTMLElement;
+    }>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
+    define<TType extends Function>(type: TType, nameOrDef?: string | import("@microsoft/fast-element").PartialFASTElementDefinition): TType;
+};
+export declare class MainApplication extends MainApplication_base {
+    provider: any;
+    connectedCallback(): void;
+    private loadRemotes;
+    providerChanged(): void;
+}
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/dts/main/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/main/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAA6B,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQjF,qBAKa,eAAgB,SAAQ,oBAAyB;IAChD,QAAQ,EAAG,GAAG,CAAC;IAEpB,iBAAiB,IAAI,IAAI;YAMlB,WAAW;IAIzB,eAAe;CAKhB"}

package/dist/dts/main/main.styles.d.ts

@@ -0,0 +1,3 @@
+import './main.css';
+export declare const MainStyles: import("@microsoft/fast-element").ElementStyles;
+//# sourceMappingURL=main.styles.d.ts.map

package/dist/dts/main/main.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.styles.d.ts","sourceRoot":"","sources":["../../../src/main/main.styles.ts"],"names":[],"mappings":"AACA,OAAO,YAAY,CAAC;AAEpB,eAAO,MAAM,UAAU,iDAWtB,CAAC"}

package/dist/dts/main/main.template.d.ts

@@ -0,0 +1,4 @@
+import type { ViewTemplate } from '@microsoft/fast-element';
+import type { MainApplication } from './main';
+export declare const MainTemplate: ViewTemplate<MainApplication>;
+//# sourceMappingURL=main.template.d.ts.map

package/dist/dts/main/main.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.template.d.ts","sourceRoot":"","sources":["../../../src/main/main.template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,eAAe,CAItD,CAAC"}

package/dist/dts/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/dts/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("@genesislcap/foundation-utils").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/dts/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,gDAA8C,CAAC"}

package/dist/esm/components/components.js

@@ -0,0 +1,36 @@
+import { __awaiter } from "tslib";
+import { fastProgress, provideFASTDesignSystem } from '@microsoft/fast-components';
+import { logger } from '../utils';
+provideFASTDesignSystem().register(fastProgress());
+var ResourceType;
+(function (ResourceType) {
+    ResourceType["LOCAL"] = "LOCAL";
+    ResourceType["REMOTE"] = "REMOTE";
+})(ResourceType || (ResourceType = {}));
+function loadZeroFallback() {
+    return import('@genesislcap/foundation-zero');
+}
+function loadZeroDesignSystem() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let type = ResourceType.REMOTE;
+        try {
+            return yield import('foundationZero/ZeroDesignSystem');
+        }
+        catch (e) {
+            type = ResourceType.LOCAL;
+            return yield loadZeroFallback();
+        }
+        finally {
+            logger.debug(`Using '${type}' version of foundationZero/ZeroDesignSystem`);
+        }
+    });
+}
+function loadRemotes(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { registerZeroDesignSystem } = yield loadZeroDesignSystem();
+        return {
+            ZeroDesignSystem: registerZeroDesignSystem(),
+        };
+    });
+}
+export { loadRemotes, loadZeroDesignSystem };

package/dist/esm/components/index.js

@@ -0,0 +1 @@
+export * from './components';

package/dist/esm/index.federated.js

@@ -0,0 +1 @@
+import('./index');

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './main/index';

package/dist/esm/main/index.js

@@ -0,0 +1,2 @@
+export * from './main.template';
+export * from './main';

package/dist/esm/main/main.js

@@ -0,0 +1,33 @@
+import { __awaiter, __decorate } from "tslib";
+import { PendingState } from '@genesislcap/foundation-utils';
+import { FASTElement, customElement, observable } from '@microsoft/fast-element';
+import * as Components from '../components';
+import { logger } from '../utils';
+import { MainStyles as styles } from './main.styles';
+import { MainTemplate as template } from './main.template';
+const name = 'foundation-progress-overlay';
+let MainApplication = class MainApplication extends PendingState(FASTElement) {
+    connectedCallback() {
+        super.connectedCallback();
+        logger.debug(`${name} is now connected to the DOM`);
+        this.loadRemotes();
+    }
+    loadRemotes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const remoteComponents = yield Components.loadRemotes({});
+        });
+    }
+    providerChanged() {
+    }
+};
+__decorate([
+    observable
+], MainApplication.prototype, "provider", void 0);
+MainApplication = __decorate([
+    customElement({
+        name,
+        template,
+        styles,
+    })
+], MainApplication);
+export { MainApplication };

package/dist/esm/main/main.styles.js

@@ -0,0 +1,14 @@
+import { css } from '@microsoft/fast-element';
+import './main.css';
+export const MainStyles = css `
+  :host {
+    contain: layout;
+  }
+
+  :host,
+  zero-design-system-provider,
+  fast-progress {
+    width: 100%;
+    margin: 0;
+  }
+`;

package/dist/esm/main/main.template.js

@@ -0,0 +1,6 @@
+import { html, ref } from '@microsoft/fast-element';
+export const MainTemplate = html `
+  <zero-design-system-provider ${ref('provider')}>
+    <fast-progress></fast-progress>
+  </zero-design-system-provider>
+`;

package/dist/esm/utils/index.js

@@ -0,0 +1 @@
+export * from './logger';

package/dist/esm/utils/logger.js

@@ -0,0 +1,2 @@
+import { createLogger } from '@genesislcap/foundation-utils';
+export const logger = createLogger('foundation-progress-overlay');

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@genesislcap/foundation-progress-overlay",
   "description": "Genesis Foundation Progress Overlay",
-  "version": "10.3.1",
+  "version": "11.3.1",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/tbd.js",
   "config": {
     "PORT": 5050
   },
   "scripts": {
-    "build": "npm run build:webpack",
+    "build": "npm run build:tsc && npm run build:webpack",
+    "build:tsc": "tsc -b ./tsconfig.build.json",
     "build:webpack": "cross-env NODE_ENV=production webpack",
     "build:webpack:make-federated-types": "make-federated-types",
     "build:webpack:stats": "cross-env ANALYZE=1 npm run build:webpack",
@@ -17,6 +18,7 @@
     "dev": "npm run dev:webpack",
     "dev:webpack": "cross-env NODE_ENV=development webpack serve --open",
     "dev:webpack:https": "npm run dev:webpack -- --https",
+    "prepare": "npm run clean && npm run build:tsc",
     "serve": "serve dist -p $npm_package_config_PORT",
     "test": "echo \"Error: no test specified\""
   },
@@ -58,8 +60,8 @@
     "webpack-merge": "^5.7.3"
   },
   "dependencies": {
-    "@genesislcap/foundation-utils": "^10.3.1",
-    "@genesislcap/foundation-zero": "^10.3.1",
+    "@genesislcap/foundation-utils": "^11.3.1",
+    "@genesislcap/foundation-zero": "^11.3.1",
     "@microsoft/fast-components": "^2.21.3",
     "@microsoft/fast-element": "^1.7.0",
     "tslib": "^2.3.1"
@@ -68,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ba5071ecd9fa59296bb4a392f960283a469cb5da"
+  "gitHead": "37e23fc1d2019709c2775b2724bb396ac5928e65"
 }