mount-observer 0.0.39 → 0.0.40

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

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

@@ -0,0 +1,159 @@
+import { Scope } from '../lib/types'
+import { CSSQuery } from '../types';
+
+export type DSS = string;
+
+export type DirectionalScopeSigils = 
+    /**
+     * upward direction, non recursive
+     */
+    |'^'  
+    /**
+     * downward direction, next element siblings only
+     */
+    |'Y' 
+    /**
+     * IdRef query
+     * 
+     */ 
+    |'?'
+    /**
+     * self
+     */
+    |'.'
+    /**
+     * modulo
+     */
+    |'%'
+    ;
+
+export type AttrSigils =
+    /**
+     * Reference to self / local element
+     */
+    '$0' |
+    /**
+     * Reference by ID
+     */
+    '#' | '@' |  '-' | '|' | '%';
+
+export type ElementSigils = '/' | '~';
+
+export type Sigils = AttrSigils | ElementSigils;
+
+export type asOptions = 
+    | 'number'
+    | 'boolean'
+    | 'string' 
+    | 'object'
+    | 'regexp' 
+    | 'urlpattern'
+    | 'boolean|number'
+;
+
+export interface Specifier {
+    /** Directional Scope Sigil */
+    dss?: DirectionalScopeSigils,
+    /**
+     * recursive
+     */
+    rec?: boolean,
+    /**
+     * root node fallback
+     */
+    rnf?: boolean,
+    /**
+     * include siblings in scope search
+     */
+    isiss?: boolean,
+    scopeS?: CSSSelector,
+    elS?: CSSSelector,
+    el?: string,
+    idRefS?: string,
+    s?: Sigils,
+
+    /**
+     * Inferred prop name
+     * This should be the last token word of the DSS expression
+     */
+    prop?: InferredPropName,
+    path?: SubPropPath;
+    /**
+     * Event Name
+     */
+    evt?: EventName;
+
+    /**
+     * RoundAbout Prop events to listen for
+     */
+    raps?: Array<string>;
+
+    ms?: MarkerString;
+    self?: boolean;
+    /**
+     * must have a dash in the localName
+     * wait for whenDefined in find
+     */
+    host?: boolean;
+    /**
+     * host prop
+     */
+    hp?: string;
+    /**
+     * host prop fallback
+     */
+    hpf?: string;
+    
+    as?: asOptions
+        
+    
+    isModulo?: boolean;
+    modulo?: Modulo;
+}
+
+export type Modulo = 'aria-rowindex' | 'aria-colindex' | 'aria-rowindextext'
+
+export type InferredPropName = string;
+
+/**
+ * can contain dot (.) for sub property access and pipes (|) for method invocations
+ */
+export type SubPropPath = string;
+
+export type EventName = string;
+
+export type CSSSelector = string;
+
+/**
+ * starts with a dash, typically all kebab case 
+ * inferrered prop name will be camel cased based on this.
+ */
+export type MarkerString = string;
+
+/**
+ * PIP stands for Partner in Prop (for now) -- supports bi-directional data flow to property
+ * IP stands for In Prop (for now) -- Data only Flow only goes in
+ * OP s
+ */
+
+export interface GetPIPOptions{
+    //name of event to listen for for when the prop being monitored for changes
+    evtName?: string,
+    isRoundAboutReady?: boolean;
+    prop?: string,
+    sota?: string,
+}
+
+/**
+ * Partner In Prop
+ */
+export interface PIP<TProp = any, TElement = Element> extends EventListenerObject{
+    readonly propagator: EventTarget;
+    async getValue(el: TElement): Promise<TProp | undefined>;
+    async setValue(el: TElement, val: TProp);
+    async hydrate(el: TElement);
+    syncVal(el: TElement);
+    disconnect();
+    toString(nv: TProp): string;
+    readonly outEvtName: string;
+}