mount-observer 0.0.38 → 0.0.40

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

@@ -0,0 +1,64 @@
+import {BEAllProps, IEnhancement} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement<HTMLFormElement>{
+    invalidIf: Array<FormCriteria>,
+    checkValidityOn: string | Array<(string | CheckEventMonitor)>,
+    checkValidityOnInit: boolean;
+}
+
+export interface AllProps extends EndUserProps{
+    invalidClassesToApply: Array<string>,
+    invalidClassesToRemove: Array<string>,
+    isValid: boolean,
+    updateCnt: number,
+}
+
+export interface FormCriteria{
+    noneOf?: Array<(string | FieldOptions)>,
+    //instructions?: string,
+    invalidCssClass: string,
+}
+
+export interface FieldIdentifierOptions {
+    name?: string,
+    prop: string,
+    find?: string,
+
+}
+
+export interface FieldValidationOptions{
+    enabled?: boolean,
+    required?: boolean,
+    min?: number | Date | string,
+    max?: number | Date | string,
+    pattern?: string,
+    type?: string,
+}
+
+export interface FieldOptions extends FieldIdentifierOptions, FieldValidationOptions{}
+
+export interface CheckEventMonitor{
+    type: string,
+    options: AddEventListenerOptions,
+}
+
+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,
+    markStatus(self: BAP): void,
+    checkValidity(self: BAP): void,
+    applyInvalidClsses(self: BAP): void,
+    removeInvalidClasses(self: BAP): void,
+    // onInvalidIf(self: this): Promise<void>;
+    // onCheckValidityOn(self: this): void;
+    // onCheckValidityOnInit(self: this): void;
+}

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

@@ -1,4 +1,4 @@
-import { CustomHandlers, ScopedCustomHandlers } from '../trans-render/be/types';
+import { CustomHandlers} from '../trans-render/be/types';
 import {StringWithAutocompleteOptions} from '../trans-render/types';
 export type aggKeys = StringWithAutocompleteOptions<
     | '+'
@@ -14,5 +14,5 @@ export type aggKeys = StringWithAutocompleteOptions<
 
 export interface Handlers{
     customHandlers: CustomHandlers;
-    scopedCustomHandlers?: ScopedCustomHandlers;
-}
+}
+

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

@@ -0,0 +1,24 @@
+import {BEAllProps, EventListenerOrFn, IEnhancement} from '../trans-render/be/types';
+
+export interface EndUserProps extends IEnhancement<HTMLElement>{
+
+}
+
+export interface AllProps extends EndUserProps{
+    isParsed?: boolean,
+}
+
+export type WithStatement = string;
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export type BAP = AP & BEAllProps;
+
+
+export interface Actions{
+    register(self: BAP): ProPAP;
+}

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;
+}