@shortfuse/materialdesignweb 0.7.6 → 0.9.0

package/types/core/Composition.d.ts

@@ -0,0 +1,252 @@
+/** @template T */
+export default class Composition<T> {
+    static EVENT_PREFIX_REGEX: RegExp;
+    static shadowRootTag: symbol;
+    /**
+     * @template T
+     * @param  {ConstructorParameters<typeof Composition<T>>} parts
+     * @return {Composition<T>}
+     */
+    static compose<T_1>(...parts: ConstructorParameters<typeof Composition<T_1>>): Composition<T_1>;
+    /**
+     * @param {(CompositionPart<T>)[]} parts
+     */
+    constructor(...parts: (CompositionPart<T>)[]);
+    _interpolationState: {
+        nodeIndex: number;
+        searchIndex: number;
+        cacheIndex: number;
+        commentIndex: number;
+        /** @type {this['nodesToBind'][0]} */
+        nodeEntry: this["nodesToBind"][0];
+    };
+    /** @type {{tag:string, textNodes: number[]}[]} */
+    nodesToBind: {
+        tag: string;
+        textNodes: number[];
+    }[];
+    /** @type {string[]} */
+    props: string[];
+    /** @type {RenderGraphSearch[]} */
+    searches: RenderGraphSearch[];
+    /** @type {any[]} */
+    initCache: any[];
+    /**
+     * Index of searches by query (dotted notation for deep props)
+     * @type {Map<Function|string, RenderGraphSearch>}
+     */
+    searchByQuery: Map<Function | string, RenderGraphSearch>;
+    /**
+     * Index of searches by query (dotted notation for deep props)
+     * @type {Map<string, RenderGraphAction[]>}
+     */
+    actionsByPropsUsed: Map<string, RenderGraphAction[]>;
+    /** @type {RenderGraphAction[]} */
+    postInitActions: RenderGraphAction[];
+    /** @type {Set<string>} */
+    tagsWithBindings: Set<string>;
+    /**
+     * Array of element tags
+     * @type {string[]}
+     */
+    tags: string[];
+    /**
+     * Data of arrays used in templates
+     * Usage of a [mdw-for] will create an ArrayLike expectation based on key
+     * Only store metadata, not actual data. Currently only needs length.
+     * TBD if more is needed later
+     * Referenced by property key (string)
+     * @type {CompositionAdapter}
+     */
+    adapter: CompositionAdapter;
+    /**
+     * Collection of events to bind.
+     * Indexed by ID
+     * @type {Map<string|symbol, CompositionEventListener<any>[]>}
+     */
+    events: Map<string | symbol, CompositionEventListener<any>[]>;
+    /**
+     * Snapshot of composition at initial state.
+     * This fragment can be cloned for first rendering, instead of calling
+     * of using `render()` to construct the initial DOM tree.
+     * @type {DocumentFragment}
+     */
+    cloneable: DocumentFragment;
+    /** @type {(HTMLStyleElement|CSSStyleSheet)[]} */
+    styles: (HTMLStyleElement | CSSStyleSheet)[];
+    /** @type {CSSStyleSheet[]} */
+    adoptedStyleSheets: CSSStyleSheet[];
+    /** @type {DocumentFragment} */
+    stylesFragment: DocumentFragment;
+    /**
+     * List of IDs used by template elements
+     * May be needed to be removed when adding to non-DocumentFragment
+     * @type {string[]}
+     */
+    allIds: string[];
+    /**
+     * Collection of IDs used for referencing elements
+     * Not meant for live DOM. Removed before attaching to document
+     */
+    /** @type {Set<string>} */
+    temporaryIds: Set<string>;
+    /** Flag set when template and styles have been interpolated */
+    interpolated: boolean;
+    /**
+     * Template used to build interpolation and cloneable
+     */
+    template: DocumentFragment;
+    /**
+     * @param {CompositionPart<T>[]} parts
+     */
+    append(...parts: CompositionPart<T>[]): this;
+    /** @param {CompositionEventListener<T>} listener */
+    addCompositionEventListener(listener: CompositionEventListener<T>): this;
+    /**
+     * TODO: Add types and clean up closure leak
+     * Updates component nodes based on data.
+     * Expects data in JSON Merge Patch format
+     * @see https://www.rfc-editor.org/rfc/rfc7386
+     * @template {Object} T
+     * @param {Partial<T>} changes what specifically
+     * @param {T} [data]
+     * @param {RenderOptions<T>} [options]
+     * @return {Function & {target:Element}} anchor
+     */
+    render<T_1 extends Object>(changes: Partial<T_1>, data?: T_1, options?: RenderOptions<T_1>): Function & {
+        target: Element;
+    };
+    /**
+     * @param {InterpolateOptions} [options]
+     */
+    interpolate(options?: InterpolateOptions): void;
+    interpolateOptions: InterpolateOptions;
+    /**
+     * @param {RenderGraphSearch} search
+     * @return {RenderGraphSearch}
+     */
+    addSearch(search: RenderGraphSearch): RenderGraphSearch;
+    /**
+     * @param {RenderGraphAction} action
+     * @return {RenderGraphAction}
+     */
+    addAction(action: RenderGraphAction): RenderGraphAction;
+    [Symbol.iterator](): Generator<CSSStyleSheet | DocumentFragment | HTMLStyleElement, void, unknown>;
+    #private;
+}
+export type CompositionPart<T> = Composition<unknown> | HTMLStyleElement | CSSStyleSheet | DocumentFragment | string;
+export type Compositor<T extends unknown> = (...parts: (CompositionPart<T>)[]) => Composition<T>;
+export type RenderOptions<T> = {
+    /**
+     * what
+     */
+    defaults?: T;
+    /**
+     * what
+     */
+    store?: T;
+    /**
+     * where
+     */
+    target?: DocumentFragment | HTMLElement | Element;
+    /**
+     * where
+     */
+    shadowRoot?: ShadowRoot;
+    /**
+     * `this` on callbacks/events
+     */
+    context?: any;
+    injections?: any;
+};
+export type HTMLElementEventMapFixed = HTMLElementEventMap & {
+    input: InputEvent;
+};
+export type HTMLElementCancellableEventMap = (Pick<HTMLElementEventMapFixed, "auxclick" | "beforeinput" | "click" | "compositionstart" | "contextmenu" | "drag" | "dragenter" | "dragover" | "dragstart" | "drop" | "invalid" | "keydown" | "keypress" | "keyup" | "mousedown" | "mousemove" | "mouseout" | "mouseover" | "mouseup" | "pointerdown" | "pointermove" | "pointerout" | "pointerover" | "pointerup" | "reset" | "selectstart" | "submit" | "touchend" | "touchmove" | "touchstart" | "wheel">);
+export type CompositionEventMap = (HTMLElementEventMapFixed & { [P in keyof HTMLElementCancellableEventMap as `~${P}`]: HTMLElementCancellableEventMap[P]; } & Record<string, Event | CustomEvent>);
+export type CompositionEventListener<T extends unknown, K extends keyof CompositionEventMap = string> = {
+    type?: K;
+    tag?: string;
+    capture?: boolean;
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+    handleEvent?: (this: T, event: (K extends keyof CompositionEventMap ? CompositionEventMap[K] : Event) & {
+        currentTarget: HTMLElement;
+    }) => any;
+    prop?: string;
+    deepProp?: string[];
+};
+export type CompositionEventListenerObject<T> = { [P in keyof CompositionEventMap]?: (keyof T & string) | ((this: T, event: CompositionEventMap[P] & {
+    currentTarget: HTMLElement;
+}) => any) | CompositionEventListener<T, P>; };
+export type NodeBindEntry<T extends unknown> = {
+    key?: string;
+    index?: number;
+    tag: string;
+    /**
+     * Index of childNode or attrName
+     */
+    subnode: string | number;
+    props: string[];
+    deepProps: string[][];
+    negate?: boolean;
+    doubleNegate?: boolean;
+    expression?: Function;
+    /**
+     * custom render function
+     */
+    render?: (options: RenderOptions<unknown>, element: Element, changes: any, data: any) => any;
+    listeners?: CompositionEventListener<T>[];
+    composition?: Composition<any>;
+    defaultValue: T;
+};
+export type RenderState = any[];
+export type RenderGraphSearch = {
+    invocation: (state: InitializationState, changes: any, data: any) => any;
+    cacheIndex: number;
+    searchIndex: number;
+    query: string | Function | string[];
+    expression?: Function;
+    prop: string;
+    deepProp: string[];
+    propsUsed: string[];
+    deepPropsUsed: string[][];
+    defaultValue: any;
+    subSearch?: RenderGraphSearch;
+};
+export type RenderGraphAction = {
+    invocation: (state: InitializationState, value: any, changes: any, data: any) => any;
+    commentIndex?: number;
+    nodeIndex?: number;
+    cacheIndex?: number;
+    attrName?: string;
+    defaultValue?: any;
+    search: RenderGraphSearch;
+};
+export type InterpolateOptions = {
+    /**
+     * Default values to use for interpolation
+     */
+    defaults?: Record<string, any>;
+    /**
+     * Context-specific injected properties. (Experimental)
+     */
+    injections?: {
+        iterable: string;
+    } & Record<string, any>;
+};
+export type InitializationState = {
+    lastElement: Element;
+    lastChildNode: ChildNode;
+    nodes: (Element | Text)[];
+    caches: any[];
+    comments: Comment[];
+    nodeStates: Uint8Array;
+    searchStates: Uint8Array;
+    refs: Element[];
+    lastChildNodeIndex: number;
+    options: RenderOptions<unknown>;
+};
+import CompositionAdapter from './CompositionAdapter.js';
+//# sourceMappingURL=Composition.d.ts.map

package/types/core/Composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Composition.d.ts","sourceRoot":"","sources":["../../core/Composition.js"],"names":[],"mappings":"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"}

package/types/core/CompositionAdapter.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @typedef {Object} DomAdapterCreateOptions
+ * @prop {Comment} anchorNode
+ * @prop {(...args:any[]) => HTMLElement} [create]
+ */
+/**
+ * @typedef {Object} ItemMetadata
+ * @prop {Element} element
+ * @prop {any} key
+ * @prop {Element|Comment} domNode
+ * @prop {Function} render
+ * @prop {boolean} [hidden]
+ * @prop {Comment} [comment]
+ */
+export default class CompositionAdapter {
+    /** @param {DomAdapterCreateOptions} options */
+    constructor(options: DomAdapterCreateOptions);
+    anchorNode: Comment;
+    /** @type {ItemMetadata[]} */
+    metadata: ItemMetadata[];
+    /**
+     * Ordered-list of metadata keys
+     * Chrome and FireFox optimize arrays for indexOf/includes
+     * Safari is faster with WeakMap.get(), but can't use Primitive keys
+     * TODO: Add Safari path
+     * @type {any[]}
+     */
+    keys: any[];
+    /**
+     * Chrome needs a hint to know we will need a fast path for array by keys.
+     */
+    needsArrayKeyFastPath: boolean;
+    composition: any;
+    renderOptions: any;
+    pendingRemoves: any[];
+    /** @type {Map<any, ItemMetadata>} */
+    metadataCache: Map<any, ItemMetadata>;
+    /** @type {Element[]} */
+    queuedElements: Element[];
+    /** @type {number|null} */
+    batchStartIndex: number | null;
+    /** @type {number|null} */
+    batchEndIndex: number | null;
+    render(changes: any, data: any): any;
+    startBatch(): void;
+    writeBatch(): void;
+    stopBatch(): void;
+    /** @param {number} index */
+    removeByIndex(index: number): void;
+    /**
+     * Worst case scenario
+     * @param {number} newIndex expectedIndex
+     * @param {*} changes
+     * @param {*} data
+     * @param {*} key
+     * @param {*} change
+     * @param {boolean} [skipOnMatch]
+     * JSON Merge has no way to express sort change and data change. Best
+     * performance is done via invoking render on sort change and another on
+     * inner change. Can't skip if mixing change types.
+     */
+    renderData(newIndex: number, changes: any, data: any, key: any, change: any, skipOnMatch?: boolean): void;
+    needsArrayFastPath: boolean;
+    removeEntries(startIndex?: number): void;
+    /**
+     * @param {number} [index]
+     * @param {ItemMetadata} [metadata]
+     * @param {any} [key]
+     * @return {boolean} changed
+     */
+    hide(index?: number, metadata?: ItemMetadata, key?: any): boolean;
+    /**
+     * @param {number} [index]
+     * @param {ItemMetadata} [metadata]
+     * @param {any} [key]
+     * @return {boolean} changed
+     */
+    show(index?: number, metadata?: ItemMetadata, key?: any): boolean;
+}
+export type DomAdapterCreateOptions = {
+    anchorNode: Comment;
+    create?: (...args: any[]) => HTMLElement;
+};
+export type ItemMetadata = {
+    element: Element;
+    key: any;
+    domNode: Element | Comment;
+    render: Function;
+    hidden?: boolean;
+    comment?: Comment;
+};
+//# sourceMappingURL=CompositionAdapter.d.ts.map

package/types/core/CompositionAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositionAdapter.d.ts","sourceRoot":"","sources":["../../core/CompositionAdapter.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;IACE,+CAA+C;IAC/C,qBADY,uBAAuB,EAoClC;IAlCC,oBAAoC;IAEpC,6BAA6B;IAC7B,UADW,YAAY,EAAE,CACP;IAClB;;;;;;OAMG;IACH,MAFU,GAAG,EAAE,CAED;IAEd;;OAEG;IACH,+BAAkC;IAElC,iBAAsC;IACtC,mBAA0C;IAE1C,sBAAwB;IAGxB,qCAAqC;IACrC,eADW,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CACR;IAEzB,wBAAwB;IACxB,gBADW,OAAO,EAAE,CACI;IAExB,0BAA0B;IAC1B,iBADW,MAAM,GAAC,IAAI,CACK;IAC3B,0BAA0B;IAC1B,eADW,MAAM,GAAC,IAAI,CACG;IAG3B,qCAEC;IAED,mBAGC;IAED,mBAMC;IAED,kBAYC;IAED,4BAA4B;IAC5B,qBADY,MAAM,QAajB;IAED;;;;;;;;;;;OAWG;IACH,qBAVW,MAAM,WACN,GAAC,QACD,GAAC,OACD,GAAC,UACD,GAAC,gBACD,OAAO,QAuIjB;IAhGK,4BAA+B;IAkGrC,yCAOC;IAED;;;;;OAKG;IACH,aALW,MAAM,aACN,YAAY,QACZ,GAAG,GACF,OAAO,CAyBlB;IAED;;;;;OAKG;IACH,aALW,MAAM,aACN,YAAY,QACZ,GAAG,GACF,OAAO,CAqBlB;CACF;;gBArTS,OAAO;aACP,CAAC,GAAG,IAAI,EAAC,GAAG,EAAE,KAAK,WAAW;;;aAK9B,OAAO;SACP,GAAG;aACH,OAAO,GAAC,OAAO;;aAEf,OAAO;cACP,OAAO"}

package/types/core/CustomElement.d.ts

@@ -0,0 +1,302 @@
+/**
+ * Clone attribute
+ * @param {string} name
+ * @param {string} target
+ * @return {(oldValue:string, newValue:string, element: CustomElement) => void}
+ */
+export function cloneAttributeCallback(name: string, target: string): (oldValue: string, newValue: string, element: CustomElement) => void;
+/**
+ * Web Component that can cache templates for minification or performance
+ */
+export default class CustomElement extends HTMLElement {
+    /** @type {string} */
+    static elementName: string;
+    /** @return {Iterable<string>} */
+    static get observedAttributes(): Iterable<string>;
+    /** @type {Composition<?>} */
+    static _composition: Composition<unknown>;
+    /** @type {Map<string, import('./observe.js').ObserverConfiguration<?,?,?>>} */
+    static _props: Map<string, import("./observe.js").ObserverConfiguration<unknown, unknown, unknown>>;
+    /** @type {Map<string, import('./observe.js').ObserverConfiguration<?,?,?>>} */
+    static _attrs: Map<string, import("./observe.js").ObserverConfiguration<unknown, unknown, unknown>>;
+    /** @type {Map<string, Function[]>} */
+    static _propChangedCallbacks: Map<string, Function[]>;
+    /** @type {Map<string, Function[]>} */
+    static _attributeChangedCallbacks: Map<string, Function[]>;
+    /** @type {((callback: CallbackArguments) => any)[]} */
+    static _onComposeCallbacks: ((callback: CallbackArguments) => any)[];
+    /** @type {((callback: CallbackArguments) => any)[]} */
+    static _onConnectedCallbacks: ((callback: CallbackArguments) => any)[];
+    /** @type {((callback: CallbackArguments) => any)[]} */
+    static _onDisconnectedCallbacks: ((callback: CallbackArguments) => any)[];
+    /** @type {((callback: CallbackArguments) => any)[]} */
+    static _onConstructedCallbacks: ((callback: CallbackArguments) => any)[];
+    static interpolatesTemplate: boolean;
+    static supportsElementInternals: boolean;
+    static supportsElementInternalsRole: boolean;
+    /** @type {boolean} */
+    static templatable: boolean;
+    static defined: boolean;
+    static autoRegistration: boolean;
+    /** @type {Map<string, typeof CustomElement>} */
+    static registrations: Map<string, typeof CustomElement>;
+    /**
+     * Expressions are idempotent functions that are selectively called whenever
+     * a render is requested.
+     * Expressions are constructed exactly as methods though differ in expected
+     * arguments. The first argument should be destructured to ensure each used
+     * property is accessed at least once in order to inspect used properties.
+     *
+     * The Composition API will inspect this function with a proxy for `this` to
+     * catalog what observables are used by the expression. This allows the
+     * Composition API to build a cache as well as selective invoke the expression
+     * only when needed.
+     *
+     * When used with in element templates, the element itself will be passed as
+     * its first argument.
+     * ````js
+     *    Button
+     *      .prop('filled', 'boolean')
+     *      .prop('outlined', 'boolean')
+     *      .expresssions({
+     *        _isFilledOrOutlined({filled, outlined}) {
+     *          return (filled || outlined)
+     *        },
+     *      })
+     *      .html`<div custom={_isFilledOrOutlined}></div>`;
+     * ````
+     *
+     * When used with external data source, that data source
+     * will be passed to the expression with all properties being `null` at first
+     * inspection.
+     * ````js
+     *    const externalData = {first: 'John', last: 'Doe'};
+     *    ContactCard
+     *      .expresssions({
+     *        _fullName({first, last}) {
+     *          return [first, last].filter(Boolean).join(' ');
+     *        },
+     *      })
+     *   myButton.render(externalData);
+     * ````
+     *
+     * Expressions may be support argumentless calls by using default
+     * parameters with `this`.
+     * ````js
+     *    Button
+     *      .expresssions({
+     *        isFilledOrOutlined({filled, outlined} = this) {
+     *          return (filled || outlined)
+     *        },
+     *      });
+     *    myButton.isFilledorOutlined();
+     * ````
+     * @type {{
+     * <
+     *  CLASS extends typeof CustomElement,
+     *  ARGS extends ConstructorParameters<CLASS>,
+     *  INSTANCE extends InstanceType<CLASS>,
+     *  PROPS extends {
+     *    [K in keyof any]: K extends `_${any}` ? ((data: INSTANCE, state?: Record<string, any>) => string|boolean|null)
+     *      : ((data?: INSTANCE, state?: Record<string, any>) => string|boolean|null)
+     *  } & ThisType<INSTANCE>
+     *  >(this: CLASS, expressions: PROPS & ThisType<INSTANCE & PROPS>):
+     *  CLASS & Class<{
+     *    [K in keyof PROPS]: K extends `_${any}` ? never : () =>  ReturnType<PROPS[K]> }
+     *    ,ARGS>
+     * }}
+     */
+    static expressions: {
+        <CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends { [K in keyof any]: K extends `_${any}` ? ((data: INSTANCE, state?: Record<string, any>) => string | boolean | null) : ((data?: INSTANCE, state?: Record<string, any>) => string | boolean | null); } & ThisType<INSTANCE>>(this: CLASS, expressions: PROPS & ThisType<INSTANCE & PROPS>): CLASS & Class<{ [K in keyof PROPS]: K extends `_${any}` ? never : () => ReturnType<PROPS[K]>; }, ARGS>;
+    };
+    static methods: typeof CustomElement.set;
+    /**
+     * @type {{
+     * <
+     * CLASS extends typeof CustomElement,
+     * ARGS extends ConstructorParameters<CLASS>,
+     * INSTANCE extends InstanceType<CLASS>,
+     * PROPS extends Partial<INSTANCE>>
+     * (this: CLASS, source: PROPS & ThisType<PROPS & INSTANCE>, options?: Partial<PropertyDescriptor>)
+     * : CLASS & Class<PROPS,ARGS>
+     * }}
+     */
+    static overrides: {
+        <CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends Partial<INSTANCE>>(this: CLASS, source: PROPS & ThisType<PROPS & INSTANCE>, options?: Partial<PropertyDescriptor>): CLASS & Class<PROPS, ARGS>;
+    };
+    /**
+     * @type {{
+     * <
+     *  CLASS extends typeof CustomElement,
+     *  ARGS extends ConstructorParameters<CLASS>,
+     *  INSTANCE extends InstanceType<CLASS>,
+     *  KEY extends string,
+     *  OPTIONS extends ObserverPropertyType
+     *    | ObserverOptions<ObserverPropertyType, unknown, INSTANCE>
+     *    | ((this:INSTANCE, data:Partial<INSTANCE>, fn?: () => any) => any),
+     *  VALUE extends Record<KEY, OPTIONS extends (...args2:any[]) => infer R ? R
+     *      : OPTIONS extends ObserverPropertyType ? import('./observe.js').ParsedObserverPropertyType<OPTIONS>
+     *      : OPTIONS extends {type: 'object'} & ObserverOptions<any, infer R> ? (unknown extends R ? object : R)
+     *      : OPTIONS extends {type: ObserverPropertyType} ? import('./observe.js').ParsedObserverPropertyType<OPTIONS['type']>
+     *      : OPTIONS extends ObserverOptions<any, infer R> ? (unknown extends R ? string : R)
+     *      : never
+     *      >
+     *  > (this: CLASS, name: KEY, options: OPTIONS)
+     *    : CLASS & Class<VALUE,ARGS>;
+     * }}
+     */
+    static props: {
+        <CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, KEY extends string, OPTIONS extends ObserverPropertyType | ObserverOptions<ObserverPropertyType, unknown, INSTANCE> | ((this: INSTANCE, data: Partial<INSTANCE>, fn?: () => any) => any), VALUE extends Record<KEY, OPTIONS extends (...args2: any[]) => infer R ? R : OPTIONS extends ObserverPropertyType ? import("./observe.js").ParsedObserverPropertyType<OPTIONS> : OPTIONS extends {
+            type: "object";
+        } & ObserverOptions<any, infer R> ? (unknown extends R ? object : R) : OPTIONS extends {
+            type: ObserverPropertyType;
+        } ? import("./observe.js").ParsedObserverPropertyType<OPTIONS["type"]> : OPTIONS extends ObserverOptions<any, infer R> ? (unknown extends R ? string : R) : never>>(this: CLASS, name: KEY, options: OPTIONS): CLASS & Class<VALUE, ARGS>;
+    };
+    static idl: typeof CustomElement.prop;
+    /**
+     * @this T
+     * @template {typeof CustomElement} T
+     * @template {keyof T} K
+     * @param {K} collection
+     * @param {T[K] extends (infer R)[] ? R : never} callback
+     */
+    static _addCallback<T extends typeof CustomElement, K extends keyof T>(this: T, collection: K, callback: T[K] extends (infer R)[] ? R : never): void;
+    static append<T extends typeof CustomElement>(this: T, ...parts: ConstructorParameters<typeof Composition<InstanceType<T>>>): T;
+    static recompose<T1 extends typeof CustomElement, T2 extends InstanceType<T1>, T3 extends CompositionCallback<T2, T2>["composed"]>(this: T1, callback: T3): T1;
+    static css<T1 extends typeof CustomElement, T2 extends TemplateStringsArray | HTMLStyleElement | CSSStyleSheet | string>(this: T1, array: T2, ...rest: T2 extends string ? any : T2 extends TemplateStringsArray ? any[] : (HTMLStyleElement | CSSStyleSheet)[]): T1;
+    static autoRegister<T extends typeof CustomElement>(this: T, elementName: string): T;
+    static html<T extends typeof CustomElement>(this: T, string: TemplateStringsArray, ...substitutions: (string | Element | ((this: InstanceType<T>, data: InstanceType<T>, injections?: any) => any))[]): T;
+    static extend<T1 extends typeof CustomElement, T2 extends T1, T3 extends (Base: T1) => T2>(this: T1, customExtender?: T3 | null): T3 extends null ? T1 : T2;
+    static setStatic<T1 extends typeof CustomElement, T2 extends { [K in keyof any]: (((this: T1, ...args: any[]) => any) | string | number | boolean | any[] | object); }>(this: T1, source: T2 & ThisType<T1 & T2>): T1 & T2;
+    static readonly<CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends object>(this: CLASS, source: PROPS & ThisType<PROPS & INSTANCE>, options?: Partial<PropertyDescriptor>): CLASS & Class<PROPS, ARGS>;
+    static set<CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends object>(this: CLASS, source: PROPS & ThisType<PROPS & INSTANCE>, options?: Partial<PropertyDescriptor>): CLASS & Class<PROPS, ARGS>;
+    static mixin<BASE extends typeof CustomElement, FN extends (...args: any[]) => any, RETURN extends ReturnType<FN>, SUBCLASS extends ClassOf<RETURN>>(this: BASE, mixin: FN): SUBCLASS & BASE;
+    static register<T extends typeof CustomElement>(this: T, elementName?: string, force?: boolean): T;
+    static get propList(): Map<string, import("./observe.js").ObserverConfiguration<any, any, any, any>>;
+    static get attrList(): Map<string, import("./observe.js").ObserverConfiguration<any, any, any, any>>;
+    static get propChangedCallbacks(): Map<string, Function[]>;
+    static get attributeChangedCallbacks(): Map<string, Function[]>;
+    static prop<CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, KEY extends string, OPTIONS extends ObserverPropertyType | ObserverOptions<ObserverPropertyType, unknown, INSTANCE> | ((this: INSTANCE, data: Partial<INSTANCE>, fn?: () => any) => any), VALUE extends Record<KEY, OPTIONS extends (...args2: any[]) => infer R ? R : OPTIONS extends ObserverPropertyType ? import("./observe").ParsedObserverPropertyType<OPTIONS> : OPTIONS extends {
+        type: "object";
+    } & ObserverOptions<any, infer R> ? (unknown extends R ? object : R) : OPTIONS extends {
+        type: ObserverPropertyType;
+    } ? import("./observe").ParsedObserverPropertyType<OPTIONS["type"]> : OPTIONS extends ObserverOptions<any, infer R> ? (unknown extends R ? string : R) : never>>(this: CLASS, name: KEY, options: OPTIONS): CLASS & Class<VALUE, ARGS>;
+    static define<CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends { [P in keyof any]: {
+        enumerable?: boolean;
+        configurable?: boolean;
+        writable?: boolean;
+        value?: any;
+        get?: ((this: INSTANCE) => any);
+        set?: (this: INSTANCE, value: any) => void;
+    } | ((this: INSTANCE, ...args: any[]) => any); }, VALUE extends { [KEY in keyof PROPS]: PROPS[KEY] extends (...args2: any[]) => infer R ? R : PROPS[KEY] extends TypedPropertyDescriptor<infer R> ? R : never; }>(this: CLASS, props: PROPS & ThisType<PROPS & INSTANCE>): CLASS & Class<VALUE, ARGS>;
+    static undefine(name: any): typeof CustomElement;
+    static observe<CLASS extends typeof CustomElement, ARGS extends ConstructorParameters<CLASS>, INSTANCE extends InstanceType<CLASS>, PROPS extends IDLParameter<INSTANCE & VALUE>, VALUE extends { [KEY in keyof PROPS]: PROPS[KEY] extends (...args2: any[]) => infer R ? R : PROPS[KEY] extends ObserverPropertyType ? import("./observe").ParsedObserverPropertyType<PROPS[KEY]> : PROPS[KEY] extends {
+        type: "object";
+    } & ObserverOptions<any, infer R> ? (unknown extends R ? object : R) : PROPS[KEY] extends {
+        type: ObserverPropertyType;
+    } ? import("./observe").ParsedObserverPropertyType<PROPS[KEY]["type"]> : PROPS[KEY] extends ObserverOptions<any, infer R> ? (unknown extends R ? string : R) : never; }>(this: CLASS, props: PROPS): CLASS & Class<VALUE, ARGS>;
+    static defineStatic<T1 extends typeof CustomElement, T2 extends IDLParameter<T1>>(this: T1, props: T2): T1 & ParsedProps<T2>;
+    static events<T extends typeof CustomElement>(this: T, listeners?: import("./Composition").CompositionEventListenerObject<InstanceType<T>>, options?: Partial<import("./Composition").CompositionEventListener<InstanceType<T>>>): T;
+    static childEvents<T extends typeof CustomElement>(this: T, listenerMap: { [P in keyof any]: import("./Composition").CompositionEventListenerObject<InstanceType<T>>; }, options?: Partial<import("./Composition").CompositionEventListener<InstanceType<T>>>): T;
+    static rootEvents<T extends typeof CustomElement>(this: T, listeners?: import("./Composition").CompositionEventListenerObject<InstanceType<T>>, options?: Partial<import("./Composition").CompositionEventListener<InstanceType<T>>>): T;
+    static on<T1 extends typeof CustomElement, T2 extends InstanceType<T1>, T3 extends CompositionCallback<T2, T2>, T4 extends keyof T3>(this: T1, name: T3 | T4, callbacks?: T3[T4] & ThisType<T2>): T1;
+    static onPropChanged<T1 extends typeof CustomElement, T2 extends InstanceType<T1>>(this: T1, options: ObjectOrObjectEntries<{ [P in keyof T2]?: (this: T2, oldValue: T2[P], newValue: T2[P], changes: any, element: T2) => void; }>): T1;
+    static onAttributeChanged<T1 extends typeof CustomElement, T2 extends InstanceType<T1>>(this: T1, options: {
+        [x: string]: (this: T2, oldValue: string, newValue: string, element: T2) => void;
+    }): T1;
+    /** @param {any[]} args */
+    constructor(...args: any[]);
+    compose(parts: (import("./Composition.js").CompositionPart<any>)[]): Composition<any>;
+    /** @type {Map<string,{stringValue:string, parsedValue:any}>} */
+    _propAttributeCache: Map<string, {
+        stringValue: string;
+        parsedValue: any;
+    }>;
+    /** @type {CallbackArguments} */
+    _callbackArguments: CallbackArguments;
+    elementInternals: ElementInternals;
+    /**
+     * Updates nodes based on data
+     * Expects data in JSON Merge Patch format
+     * @see https://www.rfc-editor.org/rfc/rfc7386
+     * @param {Partial<?>} changes
+     * @param {any} data
+     * @return {void}
+     */
+    render: Function & {
+        target: Element;
+    };
+    propChangedCallback<T extends CustomElement, K extends string = string>(this: T, name: K, oldValue: K extends keyof T ? T[K] : unknown, newValue: K extends keyof T ? T[K] : unknown, changes?: K extends keyof T ? T[K] extends object ? Partial<T[K]> : T[K] : unknown): void;
+    /**
+     * @param {string} name
+     * @param {string|null} oldValue
+     * @param {string|null} newValue
+     */
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * @param {string} name
+     * @param {any} oldValue
+     * @param {any} newValue
+     * @param {any} changes
+     */
+    _onObserverPropertyChanged(name: string, oldValue: any, newValue: any, changes: any): void;
+    patch(patch: any): void;
+    patching: boolean;
+    /**
+     * Proxy object that returns shadow DOM elements by tag.
+     * If called before interpolation (eg: on composed), returns from template
+     * @return {Record<string,HTMLElement>}
+     */
+    get refs(): Record<string, HTMLElement>;
+    get attributeCache(): Map<any, any>;
+    get static(): typeof CustomElement;
+    get unique(): boolean;
+    get callbackArguments(): CallbackArguments<any, any> | {
+        composition: Composition<any>;
+        refs: Record<string, HTMLElement>;
+        html: any;
+        inline: typeof addInlineFunction;
+        template: DocumentFragment;
+        element: this;
+    };
+    /** @return {Composition<?>} */
+    get composition(): Composition<any>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    delegatesFocus: boolean;
+    #private;
+}
+export type ObserverPropertyType = import("./observe.js").ObserverPropertyType;
+export type ParsedProps<T extends unknown> = { [P in keyof T]: T[P] extends (...args: any[]) => infer T2 ? T2 : T[P] extends ObserverPropertyType ? import("./observe.js").ParsedObserverPropertyType<T[P]> : T[P] extends {
+    type: ObserverPropertyType;
+} ? import("./observe.js").ParsedObserverPropertyType<T[P]["type"]> : T[P] extends ObserverOptions<null, infer T2> ? unknown extends T2 ? string : T2 : never; };
+export type ObserverOptions<T1 extends ObserverPropertyType, T2 extends unknown, C extends Object = any> = import("./observe.js").ObserverOptions<T1, T2, C>;
+/**
+ * <T>
+ */
+export type ClassOf<T extends {
+    prototype: unknown;
+}> = T;
+export type Class<T extends unknown = any, A extends any[] = any[]> = abstract new (...args: A) => T;
+export type HTMLTemplater<T1 extends unknown, T2 extends unknown = T1> = (string: TemplateStringsArray, ...substitutions: (string | DocumentFragment | Element | ((this: T1, data: T2) => any))[]) => DocumentFragment;
+export type CallbackArguments<T1 extends unknown = any, T2 extends unknown = T1> = {
+    composition: Composition<T1>;
+    refs: Record<string, HTMLElement>;
+    html: HTMLTemplater<T1, Partial<T2>>;
+    inline: (fn: (this: T1, data: T2) => any) => string;
+    template: DocumentFragment;
+    element: T1;
+};
+export type CompositionCallback<T1 extends unknown, T2 extends unknown = T1> = {
+    composed?: (this: T1, options: CallbackArguments<T1, T2>) => any;
+    constructed?: (this: T1, options: CallbackArguments<T1, T2>) => any;
+    connected?: (this: T1, options: CallbackArguments<T1, T2>) => any;
+    disconnected?: (this: T1, options: CallbackArguments<T1, T2>) => any;
+    props?: { [P in keyof T1]: (this: T1, oldValue: T1[P], newValue: T1[P], changes: any, element: T1) => any; };
+    attrs?: { [K in keyof any]: (this: T1, oldValue: string, newValue: string, element: T1) => unknown; };
+} & { [P in keyof T1 & string as `${P}Changed`]?: (this: T1, oldValue: T1[P], newValue: T1[P], changes: any, element: T1) => any; };
+export type IDLParameter<C extends Object> = { [P in string]: ObserverPropertyType | ObserverOptions<ObserverPropertyType, unknown, C> | ((this: C, data: Partial<C>, fn?: () => any) => any); };
+export type ObjectOrObjectEntries<T> = (T | Array<[keyof T & string, T[keyof T]]>);
+import Composition from './Composition.js';
+import { addInlineFunction } from './template.js';
+//# sourceMappingURL=CustomElement.d.ts.map