mount-observer 0.0.112 → 0.1.1

package/ts-refs/for-fetch/types.d.ts

@@ -1,83 +0,0 @@
-import { JSONObject } from '../trans-render/lib/types';
-import { Specifier } from '../trans-render/dss/types';
-import { URLBuilder } from '../../URLBuilder';
-import {SimpleWCInfo} from '../wc-info/SimpleWCInfo';
-import {EndUserProps} from './doc';
-export {EndUserProps} from './doc';
-
-declare class WeakRef<TProps = any>{}
-
-
-export interface OverridableGetters{
-    //request$: RequestInit,
-    //accept$?: string,
-    value?: any,
-    //isAttrParsed?: boolean,
-    targetSelf?: boolean
-    targetSpecifier?: Specifier
-    whenCount?: number,
-    nextWhenCount?: number,
-
-
-}
-
-export type EventName = string;
-
-export interface AllProps extends EndUserProps, OverridableGetters{
-
-    readonly resolvedTarget?: Element | null,
-
-    /**
-     * @readonly
-     * Weak references to input elements
-     */
-    readonly forRefs: Map<string, [WeakRef<HTMLInputElement>, EventName]>,
-    readonly formData?: FormData,
-    readonly formRef?: WeakRef<HTMLFormElement>,
-    readonly formSpecifier?: Specifier,
-    readonly urlBuilder?: URLBuilder,
-}
-
-export type PAP = Partial<AllProps>;
-
-export type ProPP = Promise<PAP>;
-
-
-/**
- * methods for fetch-for
- */
-export interface Methods extends Actions{
-    validateResp(resp: Response): boolean,
-    validateOn(): boolean,
-    setTargetProp(target: Element | null, data: any, shadow?: ShadowRootMode): void,
-}
-
-export interface Actions{
-    do(self: this): Promise<void>;
-    bindSrc(self)
-    parseFor(self: this): ProPP;
-    parseTarget(self: this): ProPP;
-    // listenForInput(self: this): ProPP;
-    // doInitialLoad(self: this): ProPP;
-    initializeWhen(self: this): Promise<PAP | undefined>;
-    // onForm(self: this): ProPP;
-    // onFormSpecifier(self: this): ProPP;
-    // onFormRef(self: this): Promise<void>,
-}
-
-// https://github.com/webcomponents-cg/community-protocols/issues/12#issuecomment-872415080
-export type loadEventName = 'load';
-export type inputEventName = 'input';
-export type selectionChangeEventName = 'select';
-
-export interface EventForFetch {
-    href?: string;
-    trigger?: Element,
-    forData: ForData,
-    formData: FormData,
-    body?: string | JSONObject
-}
-
-export type ForData = {[key: string]: HTMLInputElement}
-
-

package/ts-refs/mount-observer/types.d.ts

@@ -1,248 +0,0 @@
-
-export interface JSONSerializableMountInit{
-    readonly on?: CSSMatch,
-    readonly outside?: CSSMatch,
-    readonly observedAttrsWhenMounted?: (string | ObservedSourceOfTruthAttribute)[],
-    readonly whereAttr?: WhereAttr,  
-    readonly whereElementIntersectsWith?: IntersectionObserverInit,
-    readonly whereMediaMatches?: MediaQuery,
-    readonly import?: ImportString | [ImportString, ImportAssertions] | PipelineProcessor,
-
-}
-
-export interface ObservedSourceOfTruthAttribute<TProps = any>  {
-    name: string,
-    mapsTo?: keyof TProps & string,
-    valIfNull?: any,
-    valIfFalsy?: any,
-    instanceOf?: any,
-    customParser?: (newValue: string | null, oldValue: string | null, instance: Element) => any
-}
-
-export type Assigner = (target: any, source: any) => Promise<void> | void;
-
-export interface MountInit extends JSONSerializableMountInit{
-    
-    readonly withTargetShadowRoot?: ShadowRoot, 
-    readonly whereInstanceOf?: Array<{new(): Element}>,
-    readonly whereSatisfies?: PipelineProcessor<boolean>,
-    readonly do?: MountObserverCallbacks,
-    readonly assigner?: Assigner,
-    readonly idleTimeout?: number
-    // /**
-    //  * Purpose -- there are scenarios where we may only want to affect changes that occur after the initial 
-    //  * server rendering, so we only want to mount elements that appear 
-    //  */
-    // readonly ignoreInitialMatches?: boolean,
-}
-
-export interface MountObserverOptions{
-    leaveBreadcrumb?: boolean,
-}
-
-export interface MountObserverCallbacks{
-    readonly mount?: PipelineProcessor,
-    readonly dismount?: PipelineProcessor,
-    readonly disconnect?: PipelineProcessor,
-    readonly reconfirm?: PipelineProcessor,
-    readonly exit?: PipelineProcessor,
-}
-
-export interface RootCnfg{
-    start: string,
-    context: 'BuiltIn' | 'CustomElement' | 'Both'
-}
-
-//export type RootAttrOptions = Array<string | RootCnfg>;
-export type delimiter = string;
-export interface WhereAttr{
-    
-    hasBase?: string | [delimiter, string],
-    hasBranchIn?: Array<string> | [delimiter, Array<string>],
-    hasRootIn?: Array<RootCnfg>,
-    /**
-     * Used by consumers to track the universal meaning of this combination
-     * regardless of how the actual name values may be changed.
-     */
-    metadata?: any,
-}
-type CSSMatch = string;
-type ImportString = string;
-type MediaQuery = string;
-
-export interface AttribMatch{
-    names: string[],
-    //for boolean, support true/false/mixed
-    // type?: 'number' | 'string' | 'date' | 'json-object' | 'boolean',
-    // valConverter?: (s: string) => any,
-    // validator?: (v: any) => boolean;
-}
-
-export interface WeakDual<T extends Object>{
-    weakSet: WeakSet<T>,
-    setWeak: Set<WeakRef<T>>
-}
-
-export interface IMountObserver extends EventTarget {
-    // readonly mountInit: MountInit,
-    // readonly mountedRefs:  WeakRef<Element>[],
-    // readonly dismountedRefs: WeakRef<Element>[],
-    observe(within: Node): void;
-    disconnect(within: Node): void;
-    module?: any;
-    mountedElements: WeakDual<Element>;
-    readAttrs(match: Element, branchIndexes?: Set<number>) : AttrChangeInfo[];
-    observedAttrs(): Promise<Array<string> | undefined>;
-} 
-
-export interface MountContext{
-    stage?: PipelineStage,
-    initializing?: boolean,
-}
-
-type PipelineStage = 'Inspecting' | 'PreImport' | 'PostImport' | 'Import' 
-export type PipelineProcessor<ReturnType = void> = (matchingElement: Element, observer: IMountObserver, ctx: MountContext) => Promise<ReturnType> | ReturnType;
-
-//#region mutation event
-export type mutationEventName = 'mutation-event';
-export interface MutationEvent{
-    mutationRecords: Array<MutationRecord>
-}
-export type mutationEventHandler = (e: MutationEvent) => void;
-
-export interface AddMutationEventListener {
-    addEventListener(eventName: mutationEventName, handler: mutationEventHandler, options?: AddEventListenerOptions): void;
-}
-//#endregion
-
-interface AttrParts{
-    name: string,
-    root?: string,
-    base?: string,
-    branch?: string,
-    branchIdx: number,
-    leaf?: string, //TODO
-    leafIdx?: number, //TODO
-    rootCnfg?: RootCnfg,
-    metadata?: any,
-}
-
-interface AttrChangeInfo{
-    oldValue: string | null,
-    newValue: string | null,
-    isSOfTAttr: boolean,
-    idx?: number,
-    name: string,
-    parts?: AttrParts,
-    mapsTo?: string,
-}
-
-//#region mount event
-export type mountEventName = 'mount';
-export interface IMountEvent extends Event{
-    mountedElement: Element,
-}
-export type mountEventHandler = (e: IMountEvent) => void;
-
-export interface AddMountEventListener {
-    addEventListener(eventName: mountEventName, handler: mountEventHandler, options?: AddEventListenerOptions): void;
-}
-//#endregion
-
-//#region dismount event
-export type dismountEventName = 'dismount';
-export interface IDismountEvent {
-    dismountedElement: Element
-}
-
-export type dismountEventHandler = (e: IDismountEvent) => void;
-
-export interface AddDismountEventListener {
-    addEventListener(eventName: dismountEventName, handler: dismountEventHandler, options?: AddEventListenerOptions): void;
-}
-//#endregion
-
-//#region disconnected event
-export type disconnectedEventName = 'disconnect';
-export interface IDisconnectEvent {
-    disconnectedElement: Element
-}
-
-export type disconnectedEventHandler = (e: IDisconnectEvent) => void;
-
-export interface AddDisconnectEventListener {
-    addEventListener(eventName: disconnectedEventName, handler: disconnectedEventHandler, options?: AddEventListenerOptions): void;
-}
-//endregion
-
-//#region attribute change event
-export type attrChangeEventName = 'attrChange';
-export interface IAttrChangeEvent extends IMountEvent {
-    attrChangeInfos: Array<AttrChangeInfo>,
-}
-export type attrChangeEventHandler = (e: IAttrChangeEvent) => void;
-export interface AddAttrChangeEventListener{
-    addEventListener(eventName: attrChangeEventName, handler: attrChangeEventHandler, options?: AddEventListenerOptions): void;
-}
-//#endregion
-
-//#region load event
-export type loadEventName = 'load';
-export interface ILoadEvent {
-    clone: DocumentFragment
-}
-export type loadEventHandler = (e: ILoadEvent) => void;
-export interface AddLoadEventListener{
-    addEventListener(eventName: loadEventName, handler: loadEventHandler, options?: AddEventListenerOptions): void
-}
-//#endregion
-
-//#region MountObserver Script Element
-export interface MOSEAddedProps<TSynConfig=any>{
-    init: JSONSerializableMountInit;
-    observer: IMountObserver;
-    do: MountObserverCallbacks;
-    synConfig: TSynConfig;
-}
-export interface MOSE<TSynConfig=any> 
-    extends HTMLScriptElement, MOSEAddedProps<TSynConfig>{
-
-}
-
-export interface BindishOptions{
-    assigner?: Assigner,
-    //waitFor?: string,
-    /**
-     * If derived from a template, set to true
-     * to indicate that the initial 
-     */
-    csr?: boolean,
-    ctr?: IshCtr,
-    initPropVals?: any,
-}
-
-//TODO:  move to mount observer
-export interface HasIsh {
-    ish: any;
-}
-
-export interface Ishcycle{
-    '<mount>'?(self: Ishcycle, el: Element & HasIsh, options: BindishOptions): Promise<void>;
-    //'</dismount>'?(self: IshFace, el: Element): Promise<void>;
-    '<inScope>'?(self: Ishcycle, el: Element & HasIsh, options: BindishOptions): Promise<void>;
-    'arr=>'?(self: Ishcycle, arr: any[] | undefined, el: Element & HasIsh, options: BindishOptions): Promise<void | any[]>;
-    //'</outOfScope>'?(self: IshFace, el: Element): Promise<void>;
-}
-
-export type IshCtr = ({new() : Ishcycle}) | (() => Promise<{new() : Ishcycle}>);
-
-//#endregion
-
-export type RefType = '#' | '!';
-
-export interface TemplateWithRemoteContent extends HTMLTemplateElement {
-    remoteContent?: DocumentFragment,
-}
-
-
-

package/ts-refs/mt-si/types.d.ts

@@ -1,21 +0,0 @@
-import {IEnhancement, BEAllProps} from '../trans-render/be/types';
-
-export interface EndUserProps extends IEnhancement{
-    doEval: boolean;
-}
-
-export interface AllProps extends EndUserProps{
-    //enhKey: string;
-}
-
-export type AP = AllProps;
-
-export type PAP = Partial<AP>;
-
-export type ProPAP = Promise<PAP>;
-
-export type BAP = AP & BEAllProps;
-
-export interface Actions{
-    hydrate(self: BAP): ProPAP;
-}

package/ts-refs/per-each/types.d.ts

@@ -1,51 +0,0 @@
-import {IEnhancement, BEAllProps} from '../trans-render/be/types';
-import { HasIshList } from '../trans-render/dss/types';
-
-export interface EndUserProps extends IEnhancement{
-    each: string;
-    
-
-    mapIdxTo: string;
-    idxStart: number;
-    idleTimeout: number;
-    options: Partial<EndUserProps>;
-    // parsedStatements: Array<LoopingStatement>,
-    // rawStatements?: Array<string>,
-}
-
-export interface AllProps extends EndUserProps{
-    listScope: string;
-    //itemProp: string;
-    itemScopes: Array<string>;
-    itemTemplates: Array<HTMLTemplateElement>;
-    emc: any;
-    //loopingParameters: Array<LoopingParameters>,
-    ish: any;
-    ishContainer: Element;
-}
-
-export type AP = AllProps;
-
-export type PAP = Partial<AP>;
-
-export type ProPAP = Promise<PAP>;
-
-export type BAP = AP & BEAllProps;
-
-export interface Actions{
-    parse(self: BAP): PAP;
-    init(self: BAP): ProPAP;
-    hydrate(self: BAP)
-}
-
-// export interface LoopingStatement {
-//     listProp?: string;
-//     itemProp: string;
-// }
-
-// export interface LoopingParameters extends LoopingStatement {
-//     listProp: string;
-//     ish: any;
-//     ishContainer: Element;
-// }
-

package/ts-refs/soak-up/types.d.ts

@@ -1,36 +0,0 @@
-import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
-import { Specifier } from "../trans-render/dss/types";
-
-export interface EndUserProps extends IEnhancement{
-    soakUpRules: SoakUpRule[]
-}
-
-export interface AllProps extends EndUserProps{
-
-    fullyParsed?: boolean
-}
-
-export type AP = AllProps;
-
-export type PAP = Partial<AP>;
-
-export type ProPAP = Promise<PAP>;
-
-export type BAP = AP & BEAllProps;
-
-export interface Actions{
-    fullyParse(self: BAP): PAP;
-    hydrate(self: BAP): ProPAP;
-}
-
-export interface PropMap  {
-    srcProp: string,
-    destProp?: string
-}
-
-export interface SoakUpRule {
-    propMap: string
-    sourceSpecifier: Specifier
-    sourceSpecifierString: string
-    parsedPropMap: PropMap[]
-}

package/ts-refs/trans-render/XV/types.d.ts

@@ -1,69 +0,0 @@
-import { PropInfo } from "../froop/types";
-
-export type storage = 'sessionStorage' | 'localStorage';
-
-export type protocols = 
-    |   storage
-    |   'indexedDB' 
-    |   'globalThis'
-    |   'cookie'
-    |   'locationHash'
-;
-
-export type db = string;
-export type storeName = string;
-export type key = string;
-export type chainedAccessor = string;
-
-export type idbUSP = `indexedDB://${db}/${storeName}/${key}`;
-export type idbUSL = `${idbUSP}?.${chainedAccessor}`;
-
-export type storageUSP = `${storage}://${key}`;
-export type storageUSL = `${storageUSP}?.${chainedAccessor}`;
-
-export type USP = 
-    | idbUSP
-    | storageUSP
-;
-
-export type USL = 
-    | idbUSP
-    | idbUSL
-    | storageUSP
-    | storageUSL
-;
-
-export interface ParsedUSL{
-    protocol: protocols,
-    accessorChain: string,
-    usp: USP,
-    uspParts: Array<string>
-}
-
-export interface WrapperConfig<TProps = any> extends PropInfo {
-    USPProp: keyof TProps & string,
-    accessor: string,
-    cache: boolean,
-    maxStaleness: number,
-    //subscribe to window message
-    beVigilant: boolean,
-}
-
-export type USLMapping = {[key: string | number | symbol]: USL}
-
-export interface StowArgs {
-    values: any,
-    mapping: USLMapping
-}
-
-export interface SavingContext {
-    USLs: Set<USL>
-}
-
-export interface CookieOptions {
-    secure: boolean | undefined,
-    'max-age': number | undefined,
-    expires: Date | string | undefined,
-    domain: string | undefined,
-    path: string | undefined,
-}

package/ts-refs/trans-render/asmr/types.d.ts

@@ -1,138 +0,0 @@
-import { asOptions } from '../dss/types';
-import {StringWithAutocompleteOptions, ZeroOrMore} from '../types';
-
-export type ValueProp = StringWithAutocompleteOptions<
-    | 'value' 
-    | 'checked' 
-    | 'href'
-    | 'ariaValueNow'
-    | 'ariaChecked'
-    | 'valueAsNumber'
-    | 'valueAsDate'
-    | 'textContent'
-    | 'innerHTML'
->
-
-export type DisplayProp = StringWithAutocompleteOptions<
-    | 'textContent'
-    | 'ariaValueText'
->;
-
-export type ValueType = StringWithAutocompleteOptions<
-    | 'Boolean'
-    | 'String'
-    | 'Number'
-    | 'NumericRange'
->;
-
-export type TrueText = StringWithAutocompleteOptions<
-    | 'Yes'
-    | 'On'
->;
-
-export type FalseText = StringWithAutocompleteOptions<
-    | 'No'
-    | 'Off'
->;
-
-export type TrueStringValue = StringWithAutocompleteOptions<
-    | 'https://schema.org/True'
-    
->;
-
-export type FalseStringValue = StringWithAutocompleteOptions<
-    | 'https://schema.org/False'
->;
-
-export type StdEventNames = StringWithAutocompleteOptions<
-    | 'input'
-    | 'change'
-    | 'click'
-    | 'slotchange'
->;
-
-export type BuiltInEditables = StringWithAutocompleteOptions<
-    | 'input'
-    | 'select'
-    | 'textarea'
-    
->;
-
-export interface ASMROptions<TProp = any>{
-    valueProp?: ValueProp;
-    valueType?: ValueType;
-    displayProp?: DisplayProp;
-    trueText?: TrueText;
-    falseText?: FalseText;
-    trueValue?: TrueStringValue;
-    falseValue?: FalseStringValue;
-    path?: string;
-}
-
-export interface SetOptions<TProp = any> extends ASMROptions<TProp>{
-    valToDisplay?: (v: TProp) => string;
-    allowUnsafe?: boolean;
-    action?: 
-        |'set' 
-        |'toggle' 
-        |'increment' 
-        |'decrement' 
-        |'set-class'
-        |'set-part'
-    ;
-}
-
-export interface AbsOptions<TProp = any> {
-    /**
-     * source of truth attribute
-     */
-    sota?: string;
-
-    /**
-     * name of property corresponding to source of truth attribute
-     * if different from source of truth attribute
-     */
-    sotaProp?: string;
-
-    /**
-     * Is Roundabout ready
-     */
-    isRAR?: boolean;
-
-    /**
-     * Is Roundabout Emulating
-     */
-    isRAE?: boolean;
-
-    /**
-     * Is User Editable
-     */
-    isUE?: boolean;
-
-    /**
-     * User Edit Event Name
-     */
-    evt?: StdEventNames;
-
-    propToAbsorb?: ValueProp;
-
-    propToAbsorbValueType?: ValueType;
-
-    selfIsVal?: boolean;
-
-    as?: asOptions | undefined;
-}
-
-// export interface Setter<TProp = any> {
-//     setValue(nv: TProp);
-// }
-
-export interface SharingObject<TProp = any>{
-    setValue(val: TProp);
-    pureValue: TProp;
-}
-
-export interface AbsorbingObject<TProp = any> extends EventTarget{
-    getValue(): Promise<TProp>;
-
-}