mount-observer 0.0.105 → 0.0.107

package/Events.js

@@ -0,0 +1,42 @@
+//TODO:  make thes external
+// https://github.com/webcomponents-cg/community-protocols/issues/12#issuecomment-872415080
+/**
+ * The `mutation-event` event represents something that happened.
+ * We can document it here.
+ */
+export class MountEvent extends Event {
+    mountedElement;
+    initializing;
+    static eventName = 'mount';
+    constructor(mountedElement, initializing) {
+        super(MountEvent.eventName);
+        this.mountedElement = mountedElement;
+        this.initializing = initializing;
+    }
+}
+export class DismountEvent extends Event {
+    dismountedElement;
+    static eventName = 'dismount';
+    constructor(dismountedElement) {
+        super(DismountEvent.eventName);
+        this.dismountedElement = dismountedElement;
+    }
+}
+export class DisconnectEvent extends Event {
+    disconnectedElement;
+    static eventName = 'disconnect';
+    constructor(disconnectedElement) {
+        super(DisconnectEvent.eventName);
+        this.disconnectedElement = disconnectedElement;
+    }
+}
+export class AttrChangeEvent extends Event {
+    mountedElement;
+    attrChangeInfos;
+    static eventName = 'attrChange';
+    constructor(mountedElement, attrChangeInfos) {
+        super(AttrChangeEvent.eventName);
+        this.mountedElement = mountedElement;
+        this.attrChangeInfos = attrChangeInfos;
+    }
+}

package/Events.ts

@@ -0,0 +1,45 @@
+import {MountInit, IMountObserver, AddMutationEventListener, 
+    MutationEvent, dismountEventName, mountEventName, IMountEvent, IDismountEvent,
+    disconnectedEventName, IDisconnectEvent, IAttrChangeEvent, attrChangeEventName, AttrChangeInfo, loadEventName, ILoadEvent,
+    AttrParts,
+    MOSE, WeakDual,
+    MountObserverOptions,
+    Assigner,
+    RefType
+} from './ts-refs/mount-observer/types';
+//TODO:  make thes external
+// https://github.com/webcomponents-cg/community-protocols/issues/12#issuecomment-872415080
+/**
+ * The `mutation-event` event represents something that happened.
+ * We can document it here.
+ */
+export class MountEvent extends Event implements IMountEvent {
+    static eventName: mountEventName = 'mount';
+  
+    constructor(public mountedElement: Element, public initializing: boolean) {
+      super(MountEvent.eventName);
+    }
+}
+
+export class DismountEvent extends Event implements IDismountEvent{
+    static eventName: dismountEventName = 'dismount';
+
+    constructor(public dismountedElement: Element){
+        super(DismountEvent.eventName);
+    }
+}
+
+export class DisconnectEvent extends Event implements IDisconnectEvent{
+    static eventName: disconnectedEventName = 'disconnect';
+
+    constructor(public disconnectedElement: Element){
+        super(DisconnectEvent.eventName);
+    }
+}
+
+export class AttrChangeEvent extends Event implements IAttrChangeEvent{
+    static eventName: attrChangeEventName = 'attrChange';
+    constructor(public mountedElement: Element, public attrChangeInfos: Array<AttrChangeInfo>){
+        super(AttrChangeEvent.eventName);
+    }
+}

package/MountObserver.js

@@ -1,6 +1,6 @@
 import { RootMutObs } from './RootMutObs.js';
 import { bindish, bindishIt } from './bindish.js';
-import './refid/hostish.js';
+import './refid/hostish.js'; // gets embedded even if not used
 export const guid = '5Pv6bHOVH0ae07opRZ8N/g';
 export const wasItemReffed = Symbol.for('8aA6xB8+PkScmivaslBk5Q');
 export const mutationObserverLookup = new WeakMap();
@@ -73,6 +73,7 @@ export class MountObserver extends EventTarget {
         }
     }
     async #compose(el, level) {
+        //[TODO]: load async, not used often
         const src = el.getAttribute('src');
         if (src === null || src.length < 2)
             return;
@@ -84,6 +85,7 @@ export class MountObserver extends EventTarget {
     }
     #templLookUp = new Map();
     #searchForComment(refName, fragment) {
+        //get rid of
         const iterator = document.evaluate(`//comment()[.="${refName}"]`, fragment, null, XPathResult.ANY_TYPE, null);
         //console.log({xpathResult})
         try {
@@ -94,7 +96,9 @@ export class MountObserver extends EventTarget {
             return null;
         }
     }
-    async findByID(refName, fragment, refType) {
+    async findByID(
+    //[TODO]: make external, not always used
+    refName, fragment, refType) {
         if (this.#templLookUp.has(refName))
             return this.#templLookUp.get(refName);
         let templ = null;
@@ -262,6 +266,7 @@ export class MountObserver extends EventTarget {
                     elsToInspect.push(target);
                 }
                 const deletedElements = Array.from(removedNodes).filter(x => x instanceof Element);
+                const { DisconnectEvent } = await import('./Events.js');
                 for (const deletedElement of deletedElements) {
                     this.#disconnected.add(deletedElement);
                     if (doDisconnect !== undefined) {
@@ -271,6 +276,7 @@ export class MountObserver extends EventTarget {
                 }
             }
             if (attrChangeInfosMap !== undefined) {
+                const { AttrChangeEvent } = await import('./Events.js');
                 for (const [key, value] of attrChangeInfosMap) {
                     this.dispatchEvent(new AttrChangeEvent(key, value));
                 }
@@ -283,6 +289,7 @@ export class MountObserver extends EventTarget {
         await this.#inspectWithin(within, true);
     }
     static synthesize(within, customElement, mose) {
+        //TODO:  make external
         mose.type = 'mountobserver';
         const name = customElements.getName(customElement);
         if (name === null)
@@ -350,6 +357,7 @@ export class MountObserver extends EventTarget {
                 }
                 match[guid].add(this);
             }
+            const { MountEvent } = await import('./Events.js');
             this.dispatchEvent(new MountEvent(match, initializing));
             //should we automatically call readAttrs?
             //the thinking is it might make more sense to call that after mounting
@@ -357,6 +365,7 @@ export class MountObserver extends EventTarget {
         }
     }
     readAttrs(match, branchIndexes) {
+        //TODO:  externalize
         const fullListOfAttrs = this.#fullListOfEnhancementAttrs;
         const attrChangeInfos = [];
         const oldValue = null;
@@ -409,6 +418,7 @@ export class MountObserver extends EventTarget {
     }
     async #dismount(unmatching) {
         const onDismount = this.#mountInit.do?.dismount;
+        const { DismountEvent } = await import('./Events.js');
         for (const unmatch of unmatching) {
             if (onDismount !== undefined) {
                 onDismount(unmatch, this, {});
@@ -519,6 +529,7 @@ export class MountObserver extends EventTarget {
         this.#filterAndMount(els, within, false, initializing);
     }
 }
+//ToDO:  make external
 export function waitForIdleNodes(nodes, idleTimeout) {
     const mountInit = {
         idleTimeout
@@ -550,6 +561,7 @@ export function waitForIdleNodes(nodes, idleTimeout) {
         }
     });
 }
+//make external
 function areAllIdle(mutObs) {
     for (const mo of mutObs) {
         if (!mo.isIdle)
@@ -559,45 +571,4 @@ function areAllIdle(mutObs) {
 }
 const refCountErr = 'mount-observer ref count mismatch';
 export const inclTemplQry = 'template[src^="#"]:not([hidden]),template[src^="!"]:not([hidden])';
-// https://github.com/webcomponents-cg/community-protocols/issues/12#issuecomment-872415080
-/**
- * The `mutation-event` event represents something that happened.
- * We can document it here.
- */
-export class MountEvent extends Event {
-    mountedElement;
-    initializing;
-    static eventName = 'mount';
-    constructor(mountedElement, initializing) {
-        super(MountEvent.eventName);
-        this.mountedElement = mountedElement;
-        this.initializing = initializing;
-    }
-}
-export class DismountEvent extends Event {
-    dismountedElement;
-    static eventName = 'dismount';
-    constructor(dismountedElement) {
-        super(DismountEvent.eventName);
-        this.dismountedElement = dismountedElement;
-    }
-}
-export class DisconnectEvent extends Event {
-    disconnectedElement;
-    static eventName = 'disconnect';
-    constructor(disconnectedElement) {
-        super(DisconnectEvent.eventName);
-        this.disconnectedElement = disconnectedElement;
-    }
-}
-export class AttrChangeEvent extends Event {
-    mountedElement;
-    attrChangeInfos;
-    static eventName = 'attrChange';
-    constructor(mountedElement, attrChangeInfos) {
-        super(AttrChangeEvent.eventName);
-        this.mountedElement = mountedElement;
-        this.attrChangeInfos = attrChangeInfos;
-    }
-}
 //const hasRootInDefault =  ['data', 'enh', 'data-enh']

package/MountObserver.ts

@@ -9,7 +9,7 @@ import {MountInit, IMountObserver, AddMutationEventListener,
 } from './ts-refs/mount-observer/types';
 import {RootMutObs} from './RootMutObs.js';
 import {bindish, bindishIt} from './bindish.js';
-import './refid/hostish.js';
+import './refid/hostish.js';  // gets embedded even if not used
 export {MOSE} from './ts-refs/mount-observer/types';
 export const guid = '5Pv6bHOVH0ae07opRZ8N/g';
 export const wasItemReffed = Symbol.for('8aA6xB8+PkScmivaslBk5Q');
@@ -88,6 +88,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
 
 
     async #compose(el: HTMLTemplateElement, level: number){
+        //[TODO]: load async, not used often
         const src = el.getAttribute('src');
         if(src === null || src.length < 2) return;
         const refType = src[0] as RefType;
@@ -99,6 +100,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
     }
     #templLookUp: Map<string, HTMLElement> = new Map();
     #searchForComment(refName: string, fragment: Node){
+        //get rid of
         const iterator = document.evaluate(
         `//comment()[.="${refName}"]`,
         fragment,
@@ -115,6 +117,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
         }
     }
     async findByID(
+        //[TODO]: make external, not always used
         refName: string, fragment: DocumentFragment, 
         refType: RefType): Promise<HTMLElement | DocumentFragment | null>{
         if(this.#templLookUp.has(refName)) return this.#templLookUp.get(refName)!;
@@ -288,6 +291,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
                 }
 
                 const deletedElements = Array.from(removedNodes).filter(x => x instanceof Element) as Array<Element>;
+                const {DisconnectEvent} = await import('./Events.js');
                 for(const deletedElement of deletedElements){
                     this.#disconnected.add(deletedElement);
                     if(doDisconnect !== undefined){
@@ -298,6 +302,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
 
             }
             if(attrChangeInfosMap !== undefined){
+                const {AttrChangeEvent} = await import('./Events.js');
                 for(const [key, value] of attrChangeInfosMap){
                     this.dispatchEvent(new AttrChangeEvent(key, value))
                 }
@@ -312,6 +317,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
     }
 
     static synthesize(within: Document | ShadowRoot, customElement: {new(): HTMLElement}, mose: MOSE){
+        //TODO:  make external
         mose.type = 'mountobserver';
         const name = customElements.getName(customElement);
         if(name === null) throw 400;
@@ -377,6 +383,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
                 }
                 (<any>match)[guid].add(this);
             }
+            const {MountEvent} = await import('./Events.js');
             this.dispatchEvent(new MountEvent(match, initializing));
             //should we automatically call readAttrs?
             //the thinking is it might make more sense to call that after mounting
@@ -386,6 +393,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
     }
 
     readAttrs(match: Element, branchIndexes?: Set<number>){
+        //TODO:  externalize
         const fullListOfAttrs = this.#fullListOfEnhancementAttrs;
         const attrChangeInfos: Array<AttrChangeInfo> = [];
         const oldValue = null;
@@ -440,7 +448,8 @@ export class MountObserver extends EventTarget implements IMountObserver{
     }
 
     async #dismount(unmatching: Array<Element>){
-        const onDismount = this.#mountInit.do?.dismount
+        const onDismount = this.#mountInit.do?.dismount;
+        const {DismountEvent} = await import('./Events.js');
         for(const unmatch of unmatching){
             if(onDismount !== undefined){
                 onDismount(unmatch, this, {});
@@ -552,6 +561,7 @@ export class MountObserver extends EventTarget implements IMountObserver{
 
 }
 
+//ToDO:  make external
 export function waitForIdleNodes(nodes: Array<Node>, idleTimeout?: number): Promise<void>{
     const mountInit: MountInit = {
         idleTimeout
@@ -583,6 +593,7 @@ export function waitForIdleNodes(nodes: Array<Node>, idleTimeout?: number): Prom
     });
 }
 
+//make external
 function areAllIdle(mutObs: Array<RootMutObs>){
     for(const mo of mutObs){
         if(!mo.isIdle) return false;
@@ -596,41 +607,6 @@ export const inclTemplQry = 'template[src^="#"]:not([hidden]),template[src^="!"]
 
 export interface MountObserver extends IMountObserver{}
 
-// https://github.com/webcomponents-cg/community-protocols/issues/12#issuecomment-872415080
-/**
- * The `mutation-event` event represents something that happened.
- * We can document it here.
- */
-export class MountEvent extends Event implements IMountEvent {
-    static eventName: mountEventName = 'mount';
-  
-    constructor(public mountedElement: Element, public initializing: boolean) {
-      super(MountEvent.eventName);
-    }
-}
-
-export class DismountEvent extends Event implements IDismountEvent{
-    static eventName: dismountEventName = 'dismount';
-
-    constructor(public dismountedElement: Element){
-        super(DismountEvent.eventName);
-    }
-}
-
-export class DisconnectEvent extends Event implements IDisconnectEvent{
-    static eventName: disconnectedEventName = 'disconnect';
-
-    constructor(public disconnectedElement: Element){
-        super(DisconnectEvent.eventName);
-    }
-}
-
-export class AttrChangeEvent extends Event implements IAttrChangeEvent{
-    static eventName: attrChangeEventName = 'attrChange';
-    constructor(public mountedElement: Element, public attrChangeInfos: Array<AttrChangeInfo>){
-        super(AttrChangeEvent.eventName);
-    }
-}
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mount-observer",
-  "version": "0.0.105",
+  "version": "0.0.107",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",
@@ -69,6 +69,10 @@
       "default": "./refid/getCount.js",
       "types": "./refid/getCount.ts"
     },
+    "./refid/ism.js": {
+      "default": "./refid/ism.js",
+      "types": "./refid/ism.ts"
+    },
     "./refid/itemprops.js": {
       "default": "./refid/itemprops.js",
       "types": "./refid/itemprops.ts"

package/readAttrs.ts

@@ -0,0 +1,60 @@
+import { AttrChangeInfo, AttrParts, MountInit } from "./ts-refs/mount-observer/types";
+
+export function readAttrs(
+    match: Element, mountInit: MountInit, branchIndexes?: Set<number>,
+    fullListOfEnhancementAttrs?: string[],
+    attrParts?: AttrParts[],
+){
+        //TODO:  externalize
+        const fullListOfAttrs = fullListOfEnhancementAttrs;
+        const attrChangeInfos: Array<AttrChangeInfo> = [];
+        const oldValue = null;
+        if(fullListOfAttrs !== undefined){
+            
+            
+            for(let idx = 0, ii = fullListOfAttrs.length; idx < ii; idx++){
+                const parts = attrParts![idx];
+                const {branchIdx} = parts;
+                if(branchIndexes !== undefined){
+                    if(!branchIndexes.has(branchIdx)) continue;
+                }
+                const name = fullListOfAttrs[idx];
+                
+                const newValue = match.getAttribute(name);
+                
+                attrChangeInfos.push({
+                    idx,
+                    isSOfTAttr: false,
+                    newValue,
+                    oldValue,
+                    name,
+                    parts
+                });
+            }
+
+        }
+        const {observedAttrsWhenMounted} = mountInit;
+        if(observedAttrsWhenMounted !== undefined){
+            for(const observedAttr of observedAttrsWhenMounted){
+                const attrIsString = typeof observedAttr === 'string';
+                const name = attrIsString ? observedAttr : observedAttr.name;
+                let mapsTo: string | undefined;
+                let newValue = match.getAttribute(name);
+                if(!attrIsString){
+                    const {customParser, instanceOf, mapsTo: mt, valIfNull} = observedAttr;
+                    if(instanceOf || customParser) throw 'NI';
+                    if(newValue === null) newValue = valIfNull;
+                    mapsTo = mt;
+                }
+                attrChangeInfos.push({
+                    isSOfTAttr: true,
+                    newValue,
+                    oldValue,
+                    name,
+                    mapsTo
+                });
+            }
+        }
+
+        return attrChangeInfos;
+    }

package/refid/ism.js

@@ -0,0 +1,80 @@
+import { upShadowSearch } from '../upShadowSearch.js';
+import { stdVal } from './stdVal.js';
+Object.defineProperty(HTMLElement.prototype, 'ishm', {
+    get() {
+        const el = this;
+        return parse(el);
+    }
+});
+const parsedItempropmaps = new WeakMap();
+export function parse(el, obj = {}) {
+    const itemprop = el.getAttribute('itemprop');
+    if (itemprop) {
+        obj[itemprop] = stdVal(el); //TODO full logic
+    }
+    const itempropmap = el.getAttribute('itempropmap');
+    if (itempropmap) {
+        //const el = document.getElementById(itempropmap);
+        const jsonEl = upShadowSearch(el, itempropmap);
+        if (!jsonEl)
+            throw 500;
+        if (!parsedItempropmaps.has(jsonEl)) {
+            parsedItempropmaps.set(jsonEl, JSON.parse(jsonEl.innerHTML));
+        }
+        const parsed = /** @type {ItemPropMap} */ (parsedItempropmaps.get(jsonEl));
+        for (const key in parsed) {
+            const attr = el.getAttribute(key);
+            if (attr === null)
+                continue;
+            const rhs = parsed[key];
+            switch (typeof rhs) {
+                case 'string':
+                    obj[rhs] = attr;
+                    break;
+                case 'object':
+                    const { instanceOf, mapsTo } = rhs;
+                    switch (instanceOf) {
+                        case 'Number':
+                        case Number:
+                            obj[mapsTo] = Number(attr);
+                            break;
+                        case 'Object':
+                        case Object:
+                        case 'Boolean':
+                        case Boolean:
+                            obj[mapsTo] = JSON.parse(attr);
+                            break;
+                    }
+            }
+        }
+    }
+    //el.ish = obj;
+    const children = Array.from(el.children);
+    const isItemScoped = el.hasAttribute('itemscope');
+    let itemscopeMap;
+    if (isItemScoped) {
+        itemscopeMap = {};
+    }
+    for (const child of children) {
+        if (!(child instanceof HTMLElement))
+            continue;
+        const objToPass = child.hasAttribute('itemscope') ? {} : obj;
+        parse(child, objToPass);
+        const isItemScopeAndChildHasBothItempropAndItemscope = itemscopeMap && child.hasAttribute('itemprop') && child.hasAttribute('itemscope');
+        if (isItemScopeAndChildHasBothItempropAndItemscope) {
+            const itemprops = child.getAttribute('itemprop').split(" ").filter(x => x);
+            for (const itemprop of itemprops) {
+                if (!itemscopeMap[itemprop])
+                    itemscopeMap[itemprop] = [];
+                itemscopeMap[itemprop].push(objToPass);
+            }
+        }
+    }
+    // if(itemscopeMap){
+    //     el.ism = itemscopeMap;
+    // }
+    return {
+        obj,
+        itemscopeMap
+    };
+}

package/refid/ism.ts

@@ -0,0 +1,82 @@
+import {upShadowSearch} from '../upShadowSearch.js';
+import {stdVal} from './stdVal.js';
+
+Object.defineProperty(HTMLElement.prototype, 'ishm', {
+    get(){
+        const el = this as HTMLElement;
+        return parse(el);
+    }
+});
+
+const parsedItempropmaps = new WeakMap<HTMLScriptElement, any>();
+
+export function parse(el: HTMLElement, obj: any = {}){
+    const itemprop = el.getAttribute('itemprop');
+    if(itemprop){
+        obj[itemprop] = stdVal(el); //TODO full logic
+    }
+    const itempropmap = el.getAttribute('itempropmap');
+    if(itempropmap){
+        //const el = document.getElementById(itempropmap);
+        const jsonEl = upShadowSearch(el, itempropmap)
+        if(!jsonEl) throw 500;
+        if(!parsedItempropmaps.has(jsonEl)){
+            parsedItempropmaps.set(jsonEl, JSON.parse(jsonEl.innerHTML));
+        }
+        const parsed =/** @type {ItemPropMap} */  (parsedItempropmaps.get(jsonEl));
+        for(const key in parsed){
+            const attr = el.getAttribute(key);
+            if(attr === null) continue;
+            const rhs = parsed[key];
+            switch(typeof rhs){
+                case 'string':
+                    obj[rhs] = attr;
+                    break;
+                case 'object':
+                    const {instanceOf, mapsTo} = rhs;
+                    switch(instanceOf){
+                        case 'Number':
+                        case Number:
+                            obj[mapsTo] = Number(attr);
+                            break;
+                        case 'Object':
+                        case Object:
+                        case 'Boolean':
+                        case Boolean:
+                            obj[mapsTo] = JSON.parse(attr);
+                            break;
+                        
+
+                    }
+            }
+        }
+
+    }
+    //el.ish = obj;
+    const children = Array.from(el.children);
+    const isItemScoped = el.hasAttribute('itemscope');
+    let itemscopeMap: {[key: string] : any[]} | undefined;
+    if(isItemScoped){
+        itemscopeMap = {};
+    }
+    for(const child of children){ 
+        if(!(child instanceof HTMLElement)) continue;
+        const objToPass = child.hasAttribute('itemscope') ? {} : obj;
+        parse(child, objToPass);
+        const isItemScopeAndChildHasBothItempropAndItemscope = itemscopeMap && child.hasAttribute('itemprop') && child.hasAttribute('itemscope');
+        if(isItemScopeAndChildHasBothItempropAndItemscope){
+            const itemprops = child.getAttribute('itemprop')!.split(" ").filter(x => x);
+            for(const itemprop of itemprops){
+                if(!itemscopeMap![itemprop]) itemscopeMap![itemprop] = [];
+                itemscopeMap![itemprop].push(objToPass);
+            }
+        }
+    }
+    // if(itemscopeMap){
+    //     el.ism = itemscopeMap;
+    // }
+    return {
+        obj,
+        itemscopeMap
+    };
+}

package/refid/stdVal.js

@@ -0,0 +1,15 @@
+export function stdVal(el) {
+    const { localName } = el;
+    switch (localName) {
+        case 'form':
+            throw 'NI';
+        case 'input':
+            throw 'NI';
+        case 'a':
+            return el.href;
+        case 'data':
+            return JSON.parse(el.value);
+        default:
+            return el.textContent;
+    }
+}

package/refid/stdVal.ts

@@ -0,0 +1,15 @@
+export function stdVal(el: Element){
+    const {localName} = el;
+    switch(localName){
+        case 'form':
+            throw 'NI';
+        case 'input':
+            throw 'NI';
+        case 'a':
+            return (el as HTMLAnchorElement).href;
+        case 'data':
+            return JSON.parse((el as HTMLDataElement).value);
+        default:
+            return el.textContent;
+    }
+}

package/ts-refs/be-consoling/types.d.ts

@@ -0,0 +1,25 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    level: 
+        | 'log'
+        | 'warn'
+        | 'error',
+    ignore: string[]
+}
+
+export interface AllProps extends EndUserProps{}
+
+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): PAP;
+}
+
+export type dispatch = (event: Event) => boolean ;

package/ts-refs/be-evanescent/types.d.ts

@@ -0,0 +1,20 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    whenDefined: string[];
+}
+
+export interface AllProps extends EndUserProps{
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    //onWhenDefined(self: BAP): void;
+}

package/ts-refs/be-fetching/types.d.ts

@@ -0,0 +1,73 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    pre?: string,
+    post?: string,
+    on?: string,
+    eventName?: string,
+    eventCount?: number,
+    debounceDuration?: number,
+    options?: FetchOptions,
+    urlProp: string,
+    baseLink?: string,
+}
+export interface AllProps extends EndUserProps {
+    value: any;
+    interpolating: boolean;
+    full: boolean;
+    url: string;
+    urlEcho: string;
+}
+
+export interface FetchOptions {
+
+    init?: RequestInit,
+    authorization?:{
+        winObj?: 'sessionStorage' | 'localStorage',
+        key?: string
+        val?: string,
+
+    }
+    //headers?: {[key: string]: string},
+    //headerFormSelector?: string,
+    //headerFormSubmitOn?: string | string[],
+    //valObservePairs: ValObservePairs;
+}
+
+// export interface ValObservePairs{
+//     authorization?: IObserve,
+//     authorizationVal?: string,
+//     body?: IObserve,
+//     bodyVal?: any,
+//     cache?: IObserve<'default' | 'no-store' | 'reload' | 'no-cache' | 'force-cache' | 'only-if-cached'>,
+//     cacheVal?: 'default' | 'no-store' | 'reload' | 'no-cache' | 'force-cache' | 'only-if-cached',
+//     contentType?: IObserve,
+//     contentTypeVal?: string,
+//     credentials?: IObserve<'omit' | 'same-origin' | 'include'>,
+//     credentialsVal?: 'omit' | 'same-origin' | 'include',
+//     method?: IObserve<'GET' | 'POST' | 'PUT' | 'DELETE'>,
+//     methodVal?: 'GET' | 'POST' | 'PUT' | 'DELETE',
+//     mode?: IObserve<'cors' | 'no-cors' | 'same-origin' | 'navigate'>,
+//     modeVal?: 'cors' | 'no-cors' | 'same-origin' | 'navigate',
+//     redirect?: IObserve<'follow' | 'error' | 'manual'>,
+//     redirectVal?: 'follow' | 'error' | 'manual',
+//     referrerPolicy?: IObserve<'no-referrer' |  'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' |  'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url'>,
+//     referrerPolicyVal?: 'no-referrer' |  'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' |  'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url',
+// }
+
+export interface AllProps extends EndUserProps {}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    setUp(self: BAP): PAP;
+    interpolateIfValid(self: BAP): PAP | void;
+    setFullUrlIfValid(self: BAP): PAP | void;
+    fetchWhenSettled(self: BAP): Promise<PAP | void>;
+}

package/ts-refs/be-gone/types.d.ts

@@ -0,0 +1,24 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    whenMissing: string
+    onDefined: Array<string>
+    whenDef: string
+}
+
+export interface AllProps extends EndUserProps{
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    onOnDefined(self: BAP): ProPAP
+    hydrateOnMissing(self: BAP): ProPAP
+    parseWhenDef(self: BAP): PAP
+}

package/ts-refs/be-intersectional/types.d.ts

@@ -0,0 +1,37 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    options: IntersectionObserverInit;
+    rootClosest?: string;
+    observeClosest?: string;
+    enterDelay?: number;
+    exitDelay?: number;
+}
+
+export interface AP extends EndUserProps{
+    isIntersecting: boolean;
+    isIntersectingEcho: boolean;
+    isNotIntersecting: boolean;
+    isNotIntersectingEcho: boolean;
+}
+export type PAP = Partial<AP>;
+export type ProPAP = Promise<PAP>;
+export type BAP = AP & BEAllProps;
+
+export interface IntersectionalActions {
+    onOptions(self: AP & BEAllProps): PAP;
+    // onIntersectingChange(self: AP & BEAllProps): void;
+    // onNonIntersectingEcho(self: AP & BEAllProps)
+}
+
+export interface Actions extends IntersectionalActions{
+    
+    
+    onIntersecting(self: this): void;
+
+    onNotIntersecting(self: this): void;
+
+    
+
+    //onNotIntersectingEcho(self: this): void;
+}

package/ts-refs/be-lazy/types.d.ts

@@ -0,0 +1,29 @@
+import { 
+    EndUserProps as BeIntersectiontalEndUserProps, 
+    AP as BeIntersectionalAllProps,
+    BeIntersectionalActions,
+} from '../../node_modules/be-intersectional/types';
+import { BEAllProps } from '../be-enhanced/types';
+
+
+export interface EndUserProps extends BeIntersectiontalEndUserProps{
+    //transform?: {[key: string]: MatchRHS};
+    //host: any;
+    //ctx: RenderContext;
+}
+
+export interface AllProps extends BeIntersectionalAllProps, EndUserProps{}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+
+export interface BeLazyActions extends BeIntersectionalActions{
+    onIntersecting(self: AP & BEAllProps): void
+    onOptions(self: AP & BEAllProps): PAP;
+}

package/ts-refs/be-parsing/types.d.ts

@@ -0,0 +1,37 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    nudges: boolean
+}
+
+export interface AllProps extends EndUserProps{
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    do(self: BAP): Promise<void>;
+}
+
+export interface AttrInfo {
+    instanceOf:
+        | String
+        | 'String'
+        | Object
+        | 'Object'
+        | Number
+        | 'Number'
+        | Boolean
+        | 'Boolean'
+    mapsTo: string
+}
+
+export type RHS = string | AttrInfo;
+
+export type ItemPropMap = {[key: string]: RHS}

package/ts-refs/do-invoke/types.d.ts

@@ -2,11 +2,11 @@ import {IEnhancement, BEAllProps} from '../trans-render/be/types';
 import { Specifier } from '../trans-render/dss/types';
 
 export interface EndUserProps extends IEnhancement{
-
+    invokeParamSets: Array<InvokingParameters>,
 }
 
 export interface AP extends EndUserProps{
-    parsedStatements: Array<InvokingParameters>,
+    
     rawStatements: Array<string>,
 }
 
@@ -19,7 +19,7 @@ export type ProPAP  = Promise<PAP>
 export type BAP = AP & BEAllProps;
 
 export interface Actions{
-    hydrate(self: this): ProPAP;
+    hydrate(self: BAP): ProPAP;
 }
 
 export interface InvokingParameters {

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

@@ -0,0 +1,37 @@
+import {IEnhancement, BEAllProps, EMC} from '../trans-render/be/types';
+import { Specifier } from '../trans-render/dss/types';
+
+interface FetchReadyEvent {
+    url: string
+    options: RequestInit
+}
+
+export interface EndUserProps extends IEnhancement{
+    
+    
+}
+
+export interface AllProps extends EndUserProps{
+    //evtCount: number,
+    fetchReadyEvent: FetchReadyEvent
+    rawStatements: Array<string>
+    fetchForParams: Array<FetchForParameters>
+
+}
+
+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): PAP;
+    doFetch(self: BAP): void;
+}
+
+export interface FetchForParameters {
+    remoteSpecifier: Specifier
+}

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

@@ -0,0 +1,98 @@
+
+import {SimpleWCInfo} from '../wc-info/SimpleWCInfo';
+
+export interface EndUserProps {
+
+    accept?: string,
+    /**
+     * Url to invoke
+     * @readonly true
+     */
+    src?: string,
+
+    ':src': string,
+
+    /**
+     * Specifier for list of form associated or contentEditable peer elements that 
+     * should partake in forming the URL.
+     */
+    for?: string,
+
+    /**
+     * Indicates whether to treat the response as HTML or JSON or Text
+     */
+    as?: 'html' | 'json' | 'text',
+
+        /**
+     * The http verb to be used for the request
+     */
+    method?: 
+        | 'GET' 
+        | 'HEAD' 
+        | 'POST' 
+        | 'PUT' 
+        | 'DELETE' 
+        | 'OPTIONS' 
+        | 'TRACE'
+        | 'PATCH',
+    /**
+     * Either the JSON stringified or the parsed JSON object 
+     * If parsed, the web component will stringify it.
+     */
+    body?: any,
+
+    /**
+     * Request credentials
+     */
+    credentials?: RequestCredentials,
+
+    /**
+     * Directed Scoped Specifier to the 
+     * DOM element where the retrieved content should be applied.
+     */
+    target?: string,
+    /**
+     * If as=html, specify whether to (stream) the contents into an attached shadow DOM or not.
+     */
+    shadow?: ShadowRootMode,
+
+    /**
+     * Do not cache results even if the url has been invoked before.
+     */
+    noCache?: boolean,
+
+    /**
+     * Stream the contents into the target element
+     */
+    stream?: boolean,
+
+    /**
+     * Directed Scoped Specifier to a 
+     * (button) element, to delay submitting the fetch request until that button is clicked.
+     */
+    when?: string,
+
+    /**
+     * Directed Scoped Specifier to a form element
+     * that we should use to form the url and body from.
+     */
+    form?: string,
+}
+
+/**
+ * fetch-for web component
+ */
+export abstract class ForFetchInfo implements SimpleWCInfo {
+    src: './for-fetch.js';
+    tagName: 'for-fetch';
+    props: EndUserProps;
+    name: 'for-fetch';
+    homepage: 'https://github.com/bahrus/for-fetch'; 
+    license: 'MIT'; 
+    description: 'Base web component for fetch'
+    cssParts: {
+        
+    }
+}
+
+export type Package = [ForFetchInfo];

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

@@ -1,91 +1,12 @@
 import { JSONObject } from '../trans-render/lib/types';
 import { Specifier } from '../trans-render/dss/types';
 import { URLBuilder } from '../../URLBuilder';
-//import {SimpleWCInfo} from 'may-it-be/SimpleWCInfo';
+import {SimpleWCInfo} from '../wc-info/SimpleWCInfo';
+import {EndUserProps} from './doc';
+export {EndUserProps} from './doc';
 
 declare class WeakRef<TProps = any>{}
-/**
- * fetch-for props
- */
-export interface EndUserProps{
-
-    accept?: string,
-    /**
-     * Url to invoke
-     * @readonly true
-     */
-    src?: string,
-
-    ':src': string,
-
-    /**
-     * Specifier for list of form associated or contentEditable peer elements that 
-     * should partake in forming the URL.
-     */
-    for?: string,
-
-    /**
-     * Indicates whether to treat the response as HTML or JSON or Text
-     */
-    as?: 'html' | 'json' | 'text',
-
-    /**
-     * The http verb to be used for the request
-     */
-    method?: 
-        | 'GET' 
-        | 'HEAD' 
-        | 'POST' 
-        | 'PUT' 
-        | 'DELETE' 
-        | 'OPTIONS' 
-        | 'TRACE'
-        | 'PATCH',
-    /**
-     * Either the JSON stringified or the parsed JSON object 
-     * If parsed, the web component will stringify it.
-     */
-    body?: any,
-
-    /**
-     * Request credentials
-     */
-    credentials?: RequestCredentials,
 
-    /**
-     * Directed Scoped Specifier to the 
-     * DOM element where the retrieved content should be applied.
-     */
-    target?: string,
-
-    /**
-     * If as=html, specify whether to (stream) the contents into an attached shadow DOM or not.
-     */
-    shadow?: ShadowRootMode,
-
-    /**
-     * Do not cache results even if the url has been invoked before.
-     */
-    noCache?: boolean,
-
-    /**
-     * Stream the contents into the target element
-     */
-    stream?: boolean,
-
-    /**
-     * Directed Scoped Specifier to a 
-     * (button) element, to delay submitting the fetch request until that button is clicked.
-     */
-    when?: string,
-
-    /**
-     * Directed Scoped Specifier to a form element
-     * that we should use to form the url and body from.
-     */
-    form?: string,
-
-}
 
 export interface OverridableGetters{
     //request$: RequestInit,
@@ -138,7 +59,7 @@ export interface Actions{
     parseTarget(self: this): ProPP;
     // listenForInput(self: this): ProPP;
     // doInitialLoad(self: this): ProPP;
-    initializeWhen(self: this): Promise<PP | undefined>;
+    initializeWhen(self: this): Promise<PAP | undefined>;
     // onForm(self: this): ProPP;
     // onFormSpecifier(self: this): ProPP;
     // onFormRef(self: this): Promise<void>,
@@ -159,17 +80,4 @@ export interface EventForFetch {
 
 export type ForData = {[key: string]: HTMLInputElement}
 
-// /**
-//  * fetch-for web component
-//  */
-// export abstract class ForFetchInfo implements SimpleWCInfo {
-//     src: './for-fetch.js';
-//     tagName: 'for-fetch';
-//     props: EndUserProps;
-//     cssParts: {
-        
-//     }
-// }
-
-// export type Package = [ForFetchInfo];
 

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

@@ -0,0 +1,36 @@
+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/froop/types.d.ts

@@ -115,8 +115,11 @@ export interface OConfig<TProps = any, TActions = TProps, ETProps = TProps> exte
 export type Positractions<TProps = any, TActions = TProps> = 
     | Array<Positraction<TProps, TActions>>;
 
-export interface Positraction<TProps = any, TActions = TProps> extends LogicOp<TProps> {
-    do: Function | (keyof TActions & string),
+export interface Positraction<TProps = any, TActions = TProps> extends LogicOp<TProps, TActions> {
+    do: 
+        | Function 
+        | (keyof TActions & string)
+        | PropsToProps<TProps>
     ifKeyIn?: Array<keyof TProps & string>,
     ifAllOf?: Array<keyof TProps & string>,
     //ifNoneOf: Array<keyof TProps & string>,
@@ -149,7 +152,7 @@ export interface ExtHandlerOptions {
 }
 
 export type ExtHandlers<ETProps = any> =
-    | Partial<{[key in `inc_${keyof TProps & string}` & string]: ExtHandlerOptions}>
+    | Partial<{[key in `inc_${keyof ETProps & string}` & string]: ExtHandlerOptions}>
 ;
 
 export type Handlers<ETProps = any, TActions = ETProps> = 
@@ -162,7 +165,9 @@ export type ListOfLogicalExpressions<MCProps = any> = (keyof MCProps | LogicOp<M
 export type LogicOpProp<MCProps = any> = 
     |LogicOp<MCProps> | (keyof MCProps & string)[];
 
-export interface LogicOp<Props = any>{
+type PropsToProps<Props> = (x: Props) => (Promise<Partial<Props>> | Partial<Props>)
+
+export interface LogicOp<Props = any, TActions = Props>{
     /**
      * Supported by trans-render
      */
@@ -182,7 +187,10 @@ export interface LogicOp<Props = any>{
 
     delay?: number,
 
-    do?: (x: Props) => (Promise<Partial<Props>> | Partial<Props>)
+    do?:
+        | Function
+        | (keyof TActions & string)
+        | PropsToProps<Props>
 
 }
 
@@ -242,6 +250,7 @@ export interface PropInfo<TProps=any, TActions=any> extends IshPropInfo<TProps,
     parse?: boolean;
     def?: any;
     attrName?: string;
+    reflect?: boolean;
     /**
      * form associated read only property
      * https://web.dev/articles/more-capable-form-controls#:~:text=Form-associated%20custom%20elements%20aim%20to%20bridge%20the%20gap,associated%20with%20the%20form%2C%20like%20a%20browser-provided%20control.

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

@@ -55,7 +55,7 @@ export type DerivationCriteria<TProps, TMethods> = {
     //TODO
     as?: ConvertOptions,
     //TODO - applicable to arrays
-    filter?: keyof TModhods & string | ((val: any) => boolean),
+    filter?: keyof TMethods & string | ((val: any) => boolean),
     //TODO
     //map?: keyof TModhods & string | ((val: any) => any,
 };
@@ -317,7 +317,7 @@ export interface UnitOfWork<TProps, TMethods = TProps, TElement = {}>{
     /**
      * two way bind the listed props to data- attributes
      */
-    data?: Array<keyof TProp & string>
+    data?: Array<keyof TProps & string>
 
     /**
      * negate to
@@ -568,7 +568,8 @@ export type StringWithAutocompleteOptions<TOptions> =
     | TOptions;
 
 export interface Clone$Options{
-    ish: HasIshList,
+    //ish: HasIshList,
+    ish: any,
     ishContainer: Element,
     seedEl: Element,
     idxStart: number,

package/ts-refs/wc-info/SimpleWCInfo.d.ts

@@ -0,0 +1,15 @@
+export interface SimpleWCInfo<TProps = any, TPublicMethods = any>{
+    tagName: string;
+    cssParts?: {[key: string]: string};
+    props?: any;
+    methods?: any;
+    nonAttribProps?: (keyof TProps)[];
+    cssProps?: {[key: string]: string};
+    slots?: {[key: string]: string};
+    events?: {[key: string]: string};
+    name: string,
+    description: string,
+    homepage: string,
+    license: string,
+
+}