mount-observer 0.0.38 → 0.0.40

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

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

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

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

@@ -0,0 +1,188 @@
+import { AttrChangeInfo, MountInit, RootCnfg,  ObservedSourceOfTruthAttribute, MOSE} from '../../mount-observer/types';
+import { RegExpExt } from '../lib/prs/types';
+import {IObject$tring, CSSQuery, StringWithAutocompleteOptions} from '../types';
+export type stringArray = string | Array<string>;
+
+export type stringArrayOrTree = Array<string> | [string, Array<string>];
+// export interface AttrParts {
+//     root: string,
+//     base: string,
+//     branch: string,
+//     leaf: string,
+// } 
+
+
+type prefixDelimiter = '-' | ':' | '--';
+
+/**
+ * Abbrev. for EnhancementMountConfig
+ */
+export type EMC<TBranches = any, TProps = any> = EnhancementMountConfig<TBranches, TProps>
+
+export interface AttrCacheConfig {
+    enable: 'always' | 'instantiating',
+    clone?: boolean
+}
+
+export type SafeProps = StringWithAutocompleteOptions<
+    | 'textContent'
+    | 'value'
+    | 'object'
+    | 'checked'
+    | '^aria'
+>;
+
+export type EventListenerClass = {new(): EventListenerObject}
+
+export type EventListenerOrFn = EventListener | ((e: Event) => void) | EventListenerClass;
+
+export type HandlerKey = string;
+
+export type HandlerName = string;
+
+export type EventType = string;
+
+
+type CustomHandlers = Map<HandlerName, EventListenerOrFn>;
+type CustomHandlerCluster = Map<HandlerKey, CustomHandlers>;
+// type EventTypeToListenerAndOptions = Map<EventType, ListenerAndOptions>;
+// export interface ListenerAndOptions  {
+//     listener: EventListenerOrFn,
+//     options?: OnOptions
+// }
+
+export type MappedListeners = {[key: string]: EventListenerOrFn}
+
+export interface IW<T = EventTarget> {
+    q: CSSQuery,
+    /**
+     * "addEventListeners or Actions"
+     * @param eventsToAdd 
+     */
+    a(eventsToAdd: MappedListeners): IW,
+    /**
+     * set properties
+     * @param propsToMerge 
+     */
+    s(propsToMerge: Partial<T>): IW,
+    r(refs: {[key: string]: any}): IW,
+    listeners: MappedListeners,
+    props: Partial<T>,
+    refs: {[key: string]: any},
+    primaryVal: any;
+}
+
+export interface EnhancementMountConfig<TBranches = any, TProps = any>{
+    id?: string;
+    enhancedElementInstanceOf?: Array<{new(): Element}>,
+    enhancedElementMatches?: string,
+    enhPropKey: HandlerKey,
+    /**
+     * If not specified, will be defaulted to the enhPropKey
+     * This allows for registered event handlers that are tied to a particular 
+     * enhancement to be scoped within a Shadow DOM realm
+     */
+    handlerKey?: string,
+    hasRootIn?: Array<RootCnfg>,
+    preBaseDelimiter?: prefixDelimiter,
+    base?: string,
+    preBranchDelimiter?: prefixDelimiter,
+    branches?: Array<string>,
+    //TODO
+    watchedBranches?: Array<string>,
+    //TODO
+    preLeafDelimiter?: prefixDelimiter,
+    //TODO
+    leaves?: Partial<{[key in keyof TBranches & string]: stringArray}>,
+    //TODO
+    hostMatches?: CSSQuery,
+    //TODO
+    hostInstanceOf?: Array<{new(): HTMLElement}>,
+    block?: boolean,
+    //TODO
+    unblock?: boolean,
+
+    importEnh?: () => Promise<{new(): IEnhancement}> 
+
+    map?: {[key: AttrCoordinates]: AttrMapPoint<TProps>},
+    /**
+     * Observed Source of Truth Attributes [TODO, need better name]
+     */
+    osotas? : Array<ObservedSourceOfTruthAttribute<TProps>>,
+
+    cacheConfig?: AttrCacheConfig,
+
+    mapLocalNameTo?: keyof TProps,
+
+    mapEnhKeyTo?: keyof TProps,
+
+    allowedMutations?: {[key: CSSQuery]: []}
+
+    top?: EnhancementMountConfig<TBranches, TProps>,
+
+    ws?: Array<IW>,
+
+    /**
+     * map the where clause to this
+     */
+    mapWSTo?: keyof TProps,
+
+    primaryProp?: keyof TProps
+}
+
+export type AttrMapPoint<TProps = any> = keyof TProps & string | AttrMapConfig<TProps>
+
+
+export interface AttrMapConfig<TProps = any, TMethods = TProps> {
+    instanceOf?: 'Object' | 'String' | 'Object$tring' | 'Object$entences' | 'DSSArray' | 'Boolean' | 'Number',
+    mapsTo?: '.' | keyof TProps,
+    valIfFalsy?: any,
+    strValMapsTo?: keyof TProps,
+    objValMapsTo?: '.' | keyof TProps,
+    arrValMapsTo?: keyof TProps,
+    strArrMapsTo?: keyof TProps,
+    regExpExts?: Partial<{[key in keyof TProps]: RegExpExt<any>[]}>;
+    parsedRegExps?: boolean;
+}
+
+
+export type Branchitude = number;
+export type Leafitude = number;
+export type AttrCoordinates = `${Branchitude}.${Leafitude}`;
+
+
+
+export type MountBeHive<TBranches = any> = Partial<EMC<TBranches>>;
+
+export interface EnhancementInfo {
+    initialPropValues?: any,
+    initialAttrInfo?: Array<AttrChangeInfo>,
+    mountCnfg: EMC,
+    synConfig: EMC,
+    observedAttrs: Array<string> | undefined,
+    ws?: Array<IW>
+}
+
+export interface BEAllProps<TElement = Element> {
+    resolved: boolean;
+    rejected: boolean;
+    enhancedElement: TElement;
+}
+
+export interface IEnhancement<TElement = Element> extends BEAllProps<TElement>{
+    attach(el: TElement, enhancement: EnhancementInfo): Promise<void>;
+    detach(el: TElement): Promise<void>;
+    resolved: boolean;
+    rejected: boolean;
+    readonly enhancedElement: TElement;
+    whenResolved(): Promise<boolean>;
+    de(src: EventTarget, name: string) : Event,
+    attrChgCB(attrChangeInfos: Array<AttrChangeInfo>) : void,
+    channelEvent(e: Event): void;
+    //parsedFrom: string;
+    //autoImport?: boolean | string;
+}
+
+export interface OnOptions extends EventListenerOptions{
+    initOn?: 'resolved'
+}