mount-observer 0.0.104 → 0.0.106

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/itemprops.js

@@ -40,7 +40,7 @@ Object.defineProperty(Element.prototype, 'itemprops', {
             };
             proxies.set(this, new Proxy(this, handler));
         }
-        return refLookup.get(this);
+        return proxies.get(this);
     }
 });
 class ItempropManager extends EventTarget {

package/refid/itemprops.ts

@@ -40,7 +40,7 @@ Object.defineProperty(Element.prototype, 'itemprops', {
         }
 
 
-        return refLookup.get(this); 
+        return proxies.get(this); 
     }
 });
 

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];