mount-observer 0.0.39 → 0.0.40

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

@@ -1,11 +1,16 @@
 import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+import {USL} from '../trans-render/XV/types'
 
 export interface EndUserProps extends IEnhancement<HTMLInputElement>{
     readVerb: 'readAsText' | 'readAsDataURL' | 'readAsArrayBuffer' | 'readAsBinaryString';
+    writeTo: USL;
 }
 
+export type FileAndContents = [File, any];
+
 export interface AllProps extends EndUserProps{
-    fileContents: any[];
+    fileContents: Array<FileAndContents>;
+    writtenTo: Array<USL>;
 }
 
 
@@ -15,7 +20,10 @@ export type PAP = Partial<AP>;
 
 export type ProPAP = Promise<PAP>;
 
+export type BAP = AP & BEAllProps;
+
 
 export interface Actions {
-    hydrate(self: AP & BEAllProps): ProPAP
+    hydrate(self: BAP): ProPAP,
+    storeFileContents(self: BAP): ProPAP,
 }

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

@@ -0,0 +1,34 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+import {Specifier} from '../trans-render/dss/types';
+import { CSSQuery } from '../trans-render/types';
+
+export interface EndUserProps extends IEnhancement{
+}
+
+export interface AllProps extends EndUserProps{
+    parsedStatements: Array<MediatingParams>,
+    rawStatements?: Array<string>,
+    mediator?: (x: any) => any,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    warn(...data: any[]): void;
+    parseJS(self: BAP): ProPAP;
+    hydrate(self: BAP): ProPAP;
+    
+}
+
+export interface MediatingParams{
+    originPart: string,
+    targetPart: string,
+    originSpecifiers: Array<Specifier>,
+    targetCSS: CSSQuery,
+}

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

@@ -0,0 +1,20 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    ceName: 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): ProPAP;
+}
+

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

@@ -0,0 +1,18 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement{
+    jsExpr: 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{
+    processJS(self: BAP): ProPAP;
+}

package/ts-refs/{be-observant → be-observing}/types.d.ts

@@ -1,4 +1,4 @@
-import {BEAllProps, IEnhancement} from '../trans-render/be/types';
+import {BEAllProps, EnhancementInfo, IEnhancement, IW} from '../trans-render/be/types';
 import { Specifier } from "../trans-render/dss/types";
 import {aggKeys, Handlers} from '../be-hive/types';
 import { StringWithAutocompleteOptions } from '../trans-render/types';
@@ -8,12 +8,12 @@ export interface EndUserProps extends IEnhancement{
 } 
 
 export interface AllProps extends EndUserProps{
-    //observedFactors?: Array<Specifier>,
     parsedStatements: Array<ObservingParameters>,
-    //bindings?: Array<EndPoints>,
     rawStatements?: Array<string>,
     didInferring?: boolean,
-    
+    ws?: Array<IW>,
+    //enhancementInfo: EnhancementInfo,
+    enhKey: string,
 }
 
 
@@ -43,8 +43,11 @@ export interface AndIfThen{
 export interface ObservingParameters{
     localPropToSet?: string,
     remoteSpecifiers: Array<Specifier>,
+    punt: boolean,
     mappings?: Array<AndIfThen>,
     aggKey: StringWithAutocompleteOptions<aggKeys>,
+    JSExpr: string,
+    ONExpr: string,
     //aggregateRemoteVals?: 'Union' | 'Conjunction' | 'ObjectAssign' | 'Sum' | 'Product' | 'ArrayPush'
 }
 

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

@@ -0,0 +1,19 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement<HTMLScriptElement>{
+    
+}
+export interface AllProps extends EndUserProps{
+    value: any,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+
+export interface Actions{
+
+}

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

@@ -0,0 +1,66 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+import { USL } from '../trans-render/XV/types';
+
+export interface EndUserProps extends IEnhancement {
+    //params?: PersistenceParams | Array<PersistenceParams>;
+    rules: Array<PersistenceRule>
+}
+export interface AllProps extends EndUserProps{
+    noAttrs: boolean,
+    //isParsed?: boolean,
+    //persistenceParams?: Array<PersistenceParams>
+}
+
+
+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;
+    noAttrs(self: BAP): ProPAP;
+    // parameterize(self: this): ProPAP
+}
+
+export interface PersistenceRule {
+    localProp?: string,
+    localEvent?: string,
+    usl?: USL,
+}
+
+// export interface PersistenceParams<TObjectToPersist = any, TEventMap = any>{
+//     what?: {[key in keyof TObjectToPersist]: boolean | string  | WhatToPersistCriteria},
+//     where: PersistenceStorage,
+//     when?: {[key in keyof TEventMap]: boolean | EventCriteria},
+//     nudge?: boolean,
+//     persistOnUnload?: boolean,
+//     restoreIf: RestoreCriteria,
+//     eventToFire?: {
+//         type: string,
+//         bubbles: boolean,
+//         cancelable: boolean,
+//         composed: boolean,
+//     }
+// }
+
+// export interface PersistenceStorage{
+//     sessionStorage?: boolean,
+//     idb?: boolean,
+//     autoGenId?: boolean,
+//     hash?: boolean,
+// }
+
+// export interface EventCriteria{}
+
+// export interface RestoreCriteria{
+//     always?: boolean,
+// }
+
+// export interface WhatToPersistCriteria {
+//     //beBeatified: boolean
+// }

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

@@ -0,0 +1,48 @@
+import {BEAllProps, IEnhancement} from '../trans-render/be/types';
+import {Specifier, DSS} from '../trans-render/dss/types';
+
+export interface EndUserProps extends IEnhancement<HTMLFormElement>{
+    baseLink: string,
+    baseURL: string,
+    path: string,
+    headers: HeadersInit | undefined,
+    updateOn: 'input' | 'change' | 'submit',
+    submitOptions:{
+        onlyAfter: Specifier,
+        nudges: boolean,
+        disableIfNotAllConditionsAreMet: boolean
+    },
+    headerFields: Array<DSS>
+}
+
+type BeforeToken = string;
+type TokenKey = string | undefined
+
+export interface IURLBuilder{
+    readonly tokens: Array<[BeforeToken, TokenKey]>
+}
+
+export interface AllProps extends EndUserProps{
+    updateCnt: number,
+    readonly urlBuilder: IURLBuilder,
+    readonly resolvedBaseURL: true,
+    readonly fetchOptions: RequestInit,
+    readonly isFetchReady: boolean,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+export interface Actions {
+    resolveBaseLink(self: BAP): PAP;
+    specifyDefaultBaseURL(self: BAP): PAP;
+    hydrate(self: BAP): ProPAP;
+    updateAction(self: BAP): ProPAP;
+    parsePath(self: BAP): ProPAP;
+    suggestFetch(self: BAP): PAP;
+}

package/ts-refs/be-render-neutral/types.d.ts

@@ -0,0 +1,29 @@
+import {BEAllProps, IEnhancement} from '../trans-render/be/types';
+import {AbsorbingObject} from '../trans-render/asmr/types';
+
+export interface RenderingHTMLScriptElement extends HTMLScriptElement{
+    renderer: (vm: any, html: any) => any,
+}
+
+export interface EndUserProps extends IEnhancement<RenderingHTMLScriptElement>{
+    vm: any,
+    with: Array<string>,
+}
+
+export interface AP extends EndUserProps{
+    renderer: (vm: any, html: any) => any,
+    absorbingObject: AbsorbingObject
+}
+
+export type PAP = Partial<AP>;
+
+export type BAP = AP & BEAllProps;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    getRenderer(self: BAP): BAP;
+    doRender(self: BAP): void;
+    observe(self: BAP): ProPAP;
+    absorb(self: BAP, e?: Event): ProPAP;
+}

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

@@ -25,10 +25,7 @@ export interface EndUserProps extends IEnhancement<HTMLTemplateElement>{
      * Works with beOosoom decorator, so becomes inert when out of view
      */
     beOosoom?: string;
-    // On?: Array<SwitchStatement>;
-    // on?: Array<SwitchStatement>;
-    // Off?: Array<SwitchStatement>;
-    // off?: Array<SwitchStatement>;
+    js?: string;
 }
 
 export interface AllProps extends EndUserProps{
@@ -43,7 +40,8 @@ export interface AllProps extends EndUserProps{
     twoValueSwitches: Array<TwoValueSwitch>,
     offBinarySwitches?: Array<OneValueSwitch>,
     nValueSwitches?: Array<NValueScriptSwitch>
-    rawStatements?: Array<string>
+    rawStatements?: Array<string>,
+    notProcessedJS?: boolean,
 }
 
 export type SwitchStatement = string;
@@ -97,18 +95,19 @@ export type ProPAP = Promise<PAP>;
 export type BAP = AP & BEAllProps;
 
 export interface Actions{
-    calcSwitchesSatisfied(self: this): PAP;
-    calcVal(self: this): PAP;
-    onTrue(self: this): Promise<void>;
-    onFalse(self: this): Promise<void>;
+    calcSwitchesSatisfied(self: BAP): PAP;
+    calcVal(self: BAP): PAP;
+    onTrue(self: BAP): Promise<void>;
+    onFalse(self: BAP): Promise<void>;
     // addMediaListener(self: this): POA;
     // chkMedia(self: this, e: MediaQueryListEvent): PAP;
     
     // doOnBinarySwitches(self: this): Promise<void>;
-    onSingleValSwitches(self: this): Promise<void>;
-    onTwoValSwitches(self: this): Promise<void>;
-    onNValSwitches(self: this): Promise<void>;
-    onRawStatements(self: this): void;
+    onSingleValSwitches(self: BAP): Promise<void>;
+    onTwoValSwitches(self: BAP): Promise<void>;
+    onNValSwitches(self: BAP): Promise<void>;
+    onRawStatements(self: BAP): void;
+    processJS(self: BAP): ProPAP;
 }
 
 

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

@@ -0,0 +1,36 @@
+import {BEAllProps, IEnhancement} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement<HTMLLabelElement> {
+    triggerInsertPosition: InsertPosition;
+    labelTextContainer: string;
+    buttonContent: string;
+    nudge?: boolean;
+}
+
+export interface AllProps extends EndUserProps{
+    byob?: boolean;
+    trigger: WeakRef<HTMLButtonElement>
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type BAP = AP & BEAllProps
+
+export type ProPAP = Promise<PAP>;
+
+
+
+export interface Actions{
+    addTypeBtn(self: BAP): ProPAP;
+    setBtnContent(self: BAP): void;
+    openDialog(self: BAP): Promise<void>
+    // beTyped(self: this): void;
+    // finale(): void;
+}
+
+export interface ITyper{
+    showDialog(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,37 @@
+import {IEnhancement, BEAllProps} from '../trans-render/be/types';
+import {EndUserProps as BeBasedEndUserProps} from '../be-based/types';
+import {Inserts} from '../../node_modules/stream-orator/types';
+
+export interface EndUserProps extends IEnhancement{
+    from?: string,
+    to?: string,
+    shadowRootMode?: 'open' | 'closed',
+    encoding?: 'UTF-8' | 'UTF-16'
+    reqInit?: RequestInit,
+    wrapper?: string,
+    beBased?: boolean | BeBasedEndUserProps,
+    beOosoom?: string,
+    defer?: boolean,
+    inProgressCss?: string,
+    inserts?:Inserts,
+    between?: [lhs: string, rhs: string],
+    once?: boolean,
+}
+
+export interface AllProps extends EndUserProps{
+    to: string,
+    from: string,
+}
+
+export interface AllProps extends EndUserProps {}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+
+export interface Actions{
+    write(self: AP & BEAllProps): ProPAP;
+}

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

@@ -0,0 +1,175 @@
+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';
+
+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,
+    //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<PP | 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}
+
+// /**
+//  * 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/mount-observer/types.d.ts

@@ -70,6 +70,11 @@ export interface AttribMatch{
     // validator?: (v: any) => boolean;
 }
 
+export interface WeakDual<T>{
+    weakSet: WeakSet<T>,
+    setWeak: Set<WeakRef<T>>
+}
+
 export interface IMountObserver {
     // readonly mountInit: MountInit,
     // readonly mountedRefs:  WeakRef<Element>[],
@@ -77,7 +82,7 @@ export interface IMountObserver {
     observe(within: Node): void;
     disconnect(within: Node): void;
     module?: any;
-    mountedElements: WeakSet<Element>;
+    mountedElements: WeakDual<Element>;
     readAttrs(match: Element, branchIndexes?: Set<number>) : AttrChangeInfo[];
     observedAttrs(): Promise<Array<string> | undefined>;
 } 

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

@@ -0,0 +1,69 @@
+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,
+}