mount-observer 0.0.111 → 0.1.0

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

@@ -1,416 +0,0 @@
-import { IMountObserver } from '../../mount-observer/types';
-import { Scope} from '../lib/types';
-import { WrapperConfig } from '../XV/types';
-import {CSSQuery, XForm} from '../types';
-
-export interface IEventConfig<MCProps = any, MCActions = MCProps, TAction = Action>{
-    on?: string,
-    of?: 'tbd' | EventTarget,
-    doInit?: boolean,
-    options?: AddEventListenerOptions,
-    abort?: {
-        origMethName: string & keyof MCActions,
-        //destMethName: string & keyof MCActions,
-        of: 'tbd' | EventTarget,
-        on: string, 
-        
-    },
-    composedPathMatches?: string,
-}
-
-//Is anything using this anymore?
-export type ActionOnEventConfigs<MCProps = any, MCActions = MCProps, TAction = Action> = Partial<{[key in keyof MCActions]: IEventConfig<MCProps, MCActions, TAction>}>
-
-
-
-export interface IAttrChgCB{
-    instance: HTMLElement,
-    // name: string,
-    // oldVal: string,
-    // newVal: string,
-    newAttrs: {[key: string]: {oldVal: string | null, newVal: string | null}},
-    filteredAttrs: {[key: string]: string}
-}
-
-
-
-export interface IPropChg{
-    key: string,
-    oldVal: any,
-    newVal: any,
-    
-}
-
-export interface DynamicTransform {
-    scope?: Scope,
-    noCache?: boolean,
-}
-
-export interface DefineArgs<MixinCompositeProps = any, MixinCompositeActions = MixinCompositeProps, TPropInfo = PropInfo, TAction extends Action = Action<MixinCompositeProps>>{
-    superclass?: {new(): HTMLElement} | string,
-    mixins?: any[],
-    mainTemplate?: HTMLTemplateElement;
-    /** use this only for defaults that can't be JSON serialized in config */
-    complexPropDefaults?: Partial<MixinCompositeProps>;
-    /** Config should be 100% JSON serializable, or a JSON import, or an id of an be-exportable script tag */
-    config: WCConfig<MixinCompositeProps, MixinCompositeActions, TPropInfo, TAction> | (() => Promise<{default: WCConfig<MixinCompositeProps, MixinCompositeActions, TPropInfo, TAction>}>) | string;
-    // /**
-    //  * Side effects tied to actions, mostly used to load enhancement dependencies tied to 
-    //  * enhancements
-    //  */
-    // asides?: Partial<{[key in keyof MixinCompositeActions & string]: (instance: EventTarget, methodName: string, key: string) => Promise<void> }>
-}
-
-export interface WCConfig<TProps = any, TActions = TProps, TPropInfo = PropInfo, TAction = Action>{
-    tagName?: string;
-    isEnh?: boolean;
-    propDefaults?: Partial<{[key in keyof TProps]: TProps[key]}>;
-    propInfo?: Partial<{[key in keyof TProps]: TPropInfo}>;
-    wrappers?: Partial<{[key in keyof TProps]: WrapperConfig<TProps>}>;
-    derivedProps?: (keyof TProps & string)[];
-    // actions?: 
-    //     Partial<{[key in keyof MCActions & string]: TAction | keyof MCProps}> 
-    actions?: Actions<TProps, TActions>;
-    propChangeMethod?: keyof TActions;
-    style?: Partial<CSSStyleDeclaration>;
-    /**
-     * Used for providing hints to server side processing what css queries should be observed if using HTMLRewriter.
-     */
-    keyQueries?: string[];
-    formAss?: boolean;
-    compacts?: Compacts<TProps>;
-    
-}
-
-export type PropLookup<TProps = any, TActions = any> = Partial<{[key in keyof TProps]: PropInfo<TProps, TActions>}>;
-export type IshPropLookup<TProps = any, TActions = any> = Partial<{[key in keyof TProps]: IshPropInfo<TProps, TActions>}>;
-export interface IshConfig<TProps = any, TActions = TProps, ETProps = TProps>{
-    propDefaults?: Partial<{[key in keyof TProps]: TProps[key]}>;
-    propInfo?: Partial<{[key in keyof TProps]: PropInfo}>;
-    wrappers?: Partial<{[key in keyof TProps]: WrapperConfig<TProps>}>;
-    actions?: Actions<TProps, TActions>;
-    /**
-     * inferred actions
-     */
-    infractions?: Infractions<TProps>,
-    compacts?: Compacts<TProps, TActions>;
-    hitch?: Hitches<TProps, TActions>;
-    handlers?: Handlers<ETProps, TActions>;
-    extHandlers?: ExtHandlers<TProps>;
-    positractions?: Positractions<TProps, TActions>;
-    
-    isSleepless?: boolean;
-    xform?: XForm<TProps, TActions>;
-    inScopeXForms?: {[key: CSSQuery]: XForm<TProps, TActions>};
-    ishListCountProp?: keyof TProps & string;
-    defaultIshList?: any[];
-    mapParentScopeRefTo?: keyof TProps & string;
-    mapElTo?: keyof TProps & string; 
-    ignoreItemProp?: boolean;
-}
-export interface OConfig<TProps = any, TActions = TProps, ETProps = TProps> extends IshConfig<TProps, TActions, ETProps>{
-    mainTemplate?: string | HTMLTemplateElement;
-}
-
-export type Positractions<TProps = any, TActions = TProps> = 
-    | Array<Positraction<TProps, TActions>>;
-
-export interface Positraction<TProps = any, TActions = TProps> extends LogicOp<TProps, TActions> {
-    do: 
-        | Function 
-        | (keyof TActions & string)
-        | PropsToProps<TProps>
-    ifKeyIn?: Array<keyof TProps & string>,
-    ifAllOf?: Array<keyof TProps & string>,
-    //ifNoneOf: Array<keyof TProps & string>,
-    
-    pass?: Array<(keyof TProps & string) | number | boolean | '$0' | '$0+' | `\`${string}\``>,
-    assignTo?: Array<null | (keyof TProps & string)>
-}
-
-
-
-export type Compacts<TProps = any, TActions = TProps> = 
-    //| Partial<{[key in `${keyof TProps & string}_to_${keyof TProps & string}` & string]: Operation<TProps> }>
-    | Partial<{[key in `negate_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
-    | Partial<{[key in `pass_length_of_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
-    | Partial<{[key in `echo_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
-    | Partial<{[key in `echo_${keyof TProps & string}_to_${keyof TProps & string}_after`]: keyof TProps}>
-    | Partial<{[key in `when_${keyof TProps & string}_changes_call_${keyof TActions & string}`]: number}>
-    | Partial<{[key in `when_${keyof TProps & string}_changes_toggle_${keyof TProps & string}`]: number}>
-    | Partial<{[key in `when_${keyof TProps & string}_changes_inc_${keyof TProps & string}_by`]: number}>
-    | Partial<{[key in `when_${keyof TProps & string}_changes_dispatch`]: string}> //TODO
-;
-
-export type Hitches<TProps = any, TActions = TProps> = 
-    | Partial<{[key in `when_${keyof TProps & string}_emits_${keyof TProps & string}_inc_${keyof TProps & string}_by`]: number}>   
-;
-
-export interface ExtHandlerOptions {
-    on: string,
-    stopPropagation?: boolean,
-}
-
-export type ExtHandlers<ETProps = any> =
-    | Partial<{[key in `inc_${keyof ETProps & string}` & string]: ExtHandlerOptions}>
-;
-
-export type Handlers<ETProps = any, TActions = ETProps> = 
-    | Partial<{[key in `${keyof ETProps & string}_to_${keyof TActions & string}_on` & string]: string }>;
-
-
-
-export type ListOfLogicalExpressions<MCProps = any> = (keyof MCProps | LogicOp<MCProps>)[];
-
-export type LogicOpProp<MCProps = any> = 
-    |LogicOp<MCProps> | (keyof MCProps & string)[];
-
-type PropsToProps<Props> = (x: Props) => (Promise<Partial<Props>> | Partial<Props>)
-
-export interface LogicOp<Props = any, TActions = Props>{
-    /**
-     * Supported by trans-render
-     */
-    ifAllOf?: Keysh<Props>,
-
-    ifKeyIn?: Keysh<Props>,  
-
-    ifNoneOf?: Keysh<Props>,
-
-    ifEquals?: Array<Key<Props>>,
-
-    ifAtLeastOneOf?: Keysh<Props>,
-
-    ifNotAllOf?: Keysh<Props>,
-
-    debug?: boolean,
-
-    delay?: number,
-
-    do?:
-        | Function
-        | (keyof TActions & string)
-        | PropsToProps<Props>
-
-}
-
-export interface SetLogicOps<Props = any>{
-
-    a?: boolean,
-
-    ifAllOf?: Set<Key<Props>>,
-
-    ifKeyIn?: Set<Key<Props>>,  
-
-    ifNoneOf?: Set<Key<Props>>,
-
-    ifEquals?: Set<Key<Props>>,
-
-    ifAtLeastOneOf?: Set<Key<Props>>,
-
-    ifNotAllOf?: Set<Key<Props>>,
-
-    debug?: boolean,
-
-    delay?: number,
-
-    do?: (x: Props) => (Promise<Partial<Props>> | Partial<Props>),
-}
-
-export interface Action<MCProps = any, MCActions = MCProps> extends LogicOp<MCProps>{
-    target?: keyof MCProps; 
-    debug?: boolean;
-    secondArg?: any;
-    //setFree?: (keyof MCProps & string)[],
-}
-
-export interface IActionProcessor{
-    doActions(self: IActionProcessor, actions: {[methodName: string]: Action}, target: any, proxy?: any): void;
-    postHoc(self: this, action: Action, target: any, returnVal: any, proxy?: any): void;
-}
-
-type PropInfoTypes = "String" | "Number" | "Boolean" | "Object" | "RegExp";
-
-export interface IshPropInfo<TProps = any, TActions = any>{
-    type?: PropInfoTypes;
-    dry?: boolean;
-    ro?: boolean;
-    propName?: string;
-    /**
-     * Allow for discarding what is passed in favor of a modified value such as a formatted value
-     * or filtered list
-     */
-    adjuster?: 
-        |keyof TActions & string 
-        |((nv: any) => any)
-}
-
-export interface PropInfo<TProps=any, TActions=any> extends IshPropInfo<TProps, TActions>{
-
-    parse?: boolean;
-    def?: any;
-    attrName?: string;
-    reflect?: boolean;
-    /**
-     * form associated read only property
-     * https://web.dev/articles/more-capable-form-controls#:~:text=Form-associated%20custom%20elements%20aim%20to%20bridge%20the%20gap,associated%20with%20the%20form%2C%20like%20a%20browser-provided%20control.
-     * examples: form, validity, validityMessage, willValidate
-     */
-    farop?: boolean;
-    /**
-     * form associated read only method
-     * examples: checkValidity, reportValidity
-     */
-    farom?: 'checkValidity' | 'reportValidity';
-    
-    /**
-     * form associated write method
-     */
-    fawm?: 'setValidity' | 'setFormValue'
-
-    /**
-     * internals pass through property
-     * examples: role, ariaRole
-     */
-    ip?: boolean;
-
-
-}
-
-export type ConstString = string;
-
-export type NameOfProp = string;
-
-export type StringOrProp = ConstString | [NameOfProp, PropInfo];
-
-export type Parts = Array<StringOrProp>;
-
-export interface PropChangeInfo<TPropInfo = PropInfo> {
-    key: string,
-    ov: any,
-    nv: any,
-    prop: TPropInfo,
-    pcm: PropChangeMethod | undefined;
-}
-
-//are these still really used?
-export type PropChangeMoment = 'v' | '-a' | '+a' | '+qr' | '+qm';
-
-export type PropChangeMethod = (self: EventTarget, pci: PropChangeInfo, moment: PropChangeMoment) => boolean;
-
-export type Actions<TProps = any, TActions = TProps> = 
-    Partial<{[key in keyof TActions & string]: LogicOp<TProps>}>
-    //& Partial<{[key in `do_${keyof TActions & string}_on`]: Key<TActions> | Array<Key<TActions>> }> 
-;
-
-export type Checks<TProps = any, TActions = TProps> = 
-    Partial<{[key in keyof TActions & string]: SetLogicOps<TProps>}>
-
-export type roundaboutOptions<TProps = any, TActions = TProps, ETProps = TProps> = {
-    vm?: TProps & TActions & RoundaboutReady,
-    //for enhanced elements, pass in the container, referenced via $0.
-    container?: EventTarget,
-    propagate?: keyof TProps & string | Array<keyof TProps & string>,
-    actions?: Actions<TProps,TActions>,
-    compacts?: Compacts<TProps, TActions>,
-    //onsets?: Onsets<TProps, TActions>,
-    handlers?: Handlers<ETProps, TActions>,
-    hitch?: Hitches<TProps, TActions>,
-    positractions?: Positractions<TProps>,
-    mountObservers?: Set<IMountObserver>
-}
-
-export type PropsToPartialProps<TProps = any> = 
- | ((self: TProps, a: any, b: any) => Promise<Partial<TProps>>) 
- | ((self: TProps) => Partial<TProps>);
-
-export type Infractions<TProps = any> = 
-    //| PropsToPartialProps<TProps> 
-    | Array<PropsToPartialProps<TProps>> 
-
-
-
-export type Busses = {[key: string]: Set<string>};
-
-export type Routers = {[key: string]: Array<{
-    on: string,
-    do: string,
-    full: string,
-}>}
-
-export type Key<T = any> = keyof T & string;
-
-export type Keysh<T = any> = Key<T> | Array<Key<T>>;
-
-export interface RoundaboutReady{
-    /**
-     * Allow for assigning to read only props via the "backdoor"
-     * Bypasses getters / setters, sets directly to (private) memory slots
-     * Doesn't do any notification
-     * Allows for nested property setting
-    */
-    covertAssignment(obj: any): Promise<void>;
-
-    /**
-     * fires event with name matching the name of the property when the value changes (but not via covertAssignment)
-     * when property is set via public interface, not (immediately) via an action method's return object
-     */
-    readonly propagator : EventTarget | undefined;
-
-    /**
-     * 
-     * https://github.com/whatwg/dom/issues/1296
-     */
-    //readonly disconnectedSignal: AbortSignal
-
-    RAController: AbortController;
-
-    /**
-     * During this time, queues/buses continue to perform "bookkeeping"
-     * but doesn't process the queue until sleep property becomes falsy.
-     * If truthy, can call await awake() before processing should resume
-     * [TODO]
-     */  
-    readonly sleep?: number | undefined;
-
-    awake(): Promise<void>;
-
-    nudge(): void;
-
-    rock(): void;
-}
-
-
-
-export interface BaseProps{
-    proppedUp: boolean,
-    sleep?: number;
-}
-
-export interface ICompact{
-    compacts: Compacts,
-}
-
-interface CompactStatement {
-    srcKey: string,
-    destKey: string,
-    op: 'toggle' | 'negate' | 'call' | 'pass_length' | 'echo' | 'inc' | 'dispatch',
-    rhsIsDynamic: boolean
-}
-
-interface HitchStatement {
-    leftKey: string,
-    middleKey: string,
-    rightKey: string,
-    lOp: 'when'
-    lmOp: 'emits',
-    mrOp: 'inc',
-    rOp: 'by'
-}
-
-export type CommandMethod<T extends EventTarget = EventTarget> = (self: T, evt: Event) => Partial<T> | Promise<Partial<T>>
-
-export type HookupConfig<T extends EventTarget = EventTarget> = {[key: string]: CommandMethod | [string, CommandMethod]};
-
-
-

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

@@ -1,12 +0,0 @@
-import {ITransformer, UnitOfWork} from '../types.js';
-import {Mount} from '../../../Mount.js';
-export interface LocalizerProps {
-
-}
-export interface LocalizerMethods{
-    localize(model: any, transformer: ITransformer<any, any>, uow: UnitOfWork<any, any>, matchingElement: Element): string | Partial<HTMLDataElement> | Partial<HTMLTimeElement> | undefined;
-}
-
-export interface Localizer extends HTMLElement, LocalizerProps, LocalizerMethods {}
-
-export type LocalizerType = {new(): Localizer & Mount }

package/ts-refs/trans-render/lib/mixins/types.d.ts

@@ -1,42 +0,0 @@
-import {UnitOfWork, ITransformer, RHS, ToTransformer, XForm} from '../../types';
-
-export interface TemplMgmtProps<MCProps extends Partial<HTMLElement> = HTMLElement, MCMethods = MCProps>{
-    mainTemplate?: HTMLTemplateElement | string;
-    unsafeTCount: number;
-    styles?: CSSStyleSheet[] | string;
-    clonedTemplate?: Node | undefined;
-    shadowRootMode?: 'open' | 'closed' | undefined | false;
-    //xform: Partial<{[key: string]: RHS<any, any>}>,
-    /**
-     * transform within ShadowRoot if applicable
-     */
-    xform: XForm<any, any, any>,
-    /**
-     * transform applied to light children, if applicable
-     * Use ":root" to match on the root element
-     */
-    lcXform: XForm<any, any>,
-    xformImpl?: () => Promise<ToTransformer<MCProps, MCMethods>>,
-    skipTemplateClone?: boolean;
-    //homeInOn?: Partial<{[key in keyof MCProps]: Partial<{[key: string]: RHS<MCProps, MCMethods>}>}>;
-}
-
-
-export interface TemplMgmtActions{
-    doTransforms(self: this): void;
-    cloneTemplate(self: this): void;
-}
-
-export interface TemplMgmtBase extends HTMLElement, TemplMgmtProps, TemplMgmtActions{}
-
-// export interface LocalizerProps {
-
-// }
-// export interface LocalizerMethods{
-//     localize(model: any, transformer: ITransformer<any, any>, uow: UnitOfWork<any, any>, matchingElement: Element): string | Partial<HTMLDataElement> | Partial<HTMLTimeElement> | undefined;
-// }
-
-// export interface Localizer extends HTMLElement, LocalizerProps, LocalizerMethods {}
-
-// export type LocalizerType = {new(): Localizer }
-

package/ts-refs/trans-render/lib/prs/types.d.ts

@@ -1,40 +0,0 @@
-import { Scope } from "../types";
-
-export type ElTypes = '$' | '#' | '@' | '/' | '-' | '|' | '%' | '~';
-
-
-export interface ElO {
-    /**
-     * User of the name "prop" is a bit loose.  It is really a kind of identifier that 
-     * **may** map to a prop, but it will typically not will map to an actual prop of the 
-     * observed element, but rather to some property of a view model of the hosting element
-     * or of a peer, non-visual  "web component as a service" sitting somewhere inside the Shadow 
-     * DOM scope.
-     */
-    prop?: string,
-    subProp?: string,
-    elType?: ElTypes,
-    perimeter?: string,
-    event?: string,
-    //TODO
-    floor?: string,
-    marker?: string,
-    scope?: Scope,
-}
-
-export interface RegExpExt<TStatementGroup = any>{
-    regExp: RegExp | string,
-    defaultVals: Partial<TStatementGroup>,
-    dssKeys?: [string, string][],
-    dssArrayKeys?: [string, string][],
-    statementPartParser?: StatementPartParser,
-
-}
-
-export interface StatementPartParser {
-    splitWord: string,
-    propMap: {[key: string]: Array<RegExpExt>},
-    parsedRegExps?: boolean,
-}
-
-export type RegExpOrRegExpExt<TStatementGroup = any> = RegExp | RegExpExt<TStatementGroup>;