mount-observer 0.1.13 → 0.1.15

package/index.js

@@ -6,7 +6,7 @@ export { arr } from './arr.js';
 export { EvtRt } from './EvtRt.js';
 export { DefineCustomElementHandler, DefineScopedCustomElementHandler } from './handlers/DefineCustomElement.js';
 export { EnhanceMountedElementHandler } from './handlers/EnhanceMountedElement.js';
-export { ScriptNoModuleHandler } from './handlers/ScriptNoModule.js';
+export { ScriptExportHandler } from './handlers/ScriptExport.js';
 export { MountObserverScriptHandler } from './handlers/MountObserverScript.js';
 export { HoistTemplateHandler } from './handlers/HoistTemplate.js';
 export { HTMLIncludeHandler } from './handlers/HTMLInclude.js';
@@ -17,7 +17,7 @@ import './EvtRt.js';
 import './handlers/DefineCustomElement.js';
 import './handlers/EnhanceMountedElement.js';
 import './handlers/GenIds.js'; // Temporarily disabled due to missing dependency
-import './handlers/ScriptNoModule.js';
+import './handlers/ScriptExport.js';
 import './handlers/MountObserverScript.js';
 import './handlers/HoistTemplate.js';
 import './handlers/HTMLInclude.js';

package/index.ts

@@ -6,7 +6,7 @@ export { arr } from './arr.js';
 export { EvtRt } from './EvtRt.js';
 export { DefineCustomElementHandler, DefineScopedCustomElementHandler } from './handlers/DefineCustomElement.js';
 export { EnhanceMountedElementHandler } from './handlers/EnhanceMountedElement.js';
-export { ScriptNoModuleHandler } from './handlers/ScriptNoModule.js';
+export { ScriptExportHandler } from './handlers/ScriptExport.js';
 export { MountObserverScriptHandler } from './handlers/MountObserverScript.js';
 export { HoistTemplateHandler } from './handlers/HoistTemplate.js';
 export { HTMLIncludeHandler } from './handlers/HTMLInclude.js';
@@ -35,7 +35,7 @@ import './EvtRt.js';
 import './handlers/DefineCustomElement.js';
 import './handlers/EnhanceMountedElement.js';
 import './handlers/GenIds.js'; // Temporarily disabled due to missing dependency
-import './handlers/ScriptNoModule.js';
+import './handlers/ScriptExport.js';
 import './handlers/MountObserverScript.js';
 import './handlers/HoistTemplate.js';
 import './handlers/HTMLInclude.js';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mount-observer",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",
   "dependencies": {
-    "assign-gingerly": "0.0.22",
+    "assign-gingerly": "0.0.23",
     "id-generation": "0.0.4"
   },
   "devDependencies": {
@@ -48,11 +48,21 @@
     "./upShadowSearch.js": {
       "default": "./upShadowSearch.js",
       "types": "./upShadowSearch.ts"
+    },
+    "./handlers/*": {
+      "default": "./handlers/*"
     }
   },
   "files": [
     "*.js",
-    "*.ts"
+    "*.ts",
+    "handlers/**/*.js",
+    "handlers/**/*.ts",
+    "types/**/*.d.ts",
+    "refid/**/*.js",
+    "refid/**/*.ts",
+    "slotkin/**/*.js",
+    "slotkin/**/*.ts"
   ],
   "types": "./types/mount-observer/types.d.ts",
   "scripts": {

package/types/assign-gingerly/types.d.ts

@@ -0,0 +1,244 @@
+export type EnhKey = string | symbol;
+
+// type NoUnderscore<T extends string> = T extends `_${string}` ? never : T;
+
+// type YesUnderscore = `_${string}`;
+
+// export type StringWithAutocompleteOptions<TOptions> = 
+//     | (string & {})
+//     | TOptions;
+
+// export type StringNotStartWithUnderscoreAutocompleteOptions<TOptions> = 
+//     | (NoUnderscore<string> & {})
+//     | TOptions;
+
+// export type StringStartWithUnderscoreAutocompleteOptions<TOptions> = 
+//     | (YesUnderscore & {})
+//     | TOptions;
+
+//used by mount-observer, not by assign-gingerly
+type DisposeEvent = 
+    | 'disconnect' 
+    | 'dismount'
+    // cannot polyfill
+    | 'exit' // element moved outside customElementRegistry
+    //reference count outside any enhancements goes to zero
+    | 'dispose'
+
+export type Spawner<T = any, Obj = Element> = {
+  new (obj?: Obj, ctx?: SpawnContext<T>, initVals?: Partial<T>): T;
+  canSpawn?: (obj: any, ctx?: SpawnContext<T>) => boolean;
+}
+
+/**
+ * Configuration for enhancing elements with class instances
+ * Defines how to spawn and initialize enhancement classes
+ */
+export interface EnhancementConfig<T = any, Obj = Element> {
+  
+  spawn: Spawner<T, Obj>;
+  
+  //Applicable to passing in the initVals during the spawn lifecycle event
+  withAttrs?: AttrPatterns<T>;
+  
+  //Allow unprefixed attributes for custom elements and SVG when element tag name matches pattern
+  allowUnprefixed?: string | RegExp;
+  
+  //keys of type symbol are used for dependency injection
+  //and are used by assign-gingerly
+  symlinks?: { [key: symbol]: keyof T };
+  //only applicable when spawning from a DOM Element reference
+  enhKey?: EnhKey;
+  lifecycleKeys?: 
+    | true  // Use standard names: "dispose" method, "resolved" property/event
+    | {
+        dispose?: string | symbol,
+        resolved?: string | symbol
+      }
+  //used by mount-observer, not by assign-gingerly
+  //impossible to polyfill, but will always be disposed
+  //when oElement's reference count goes to zero
+  disposeOn?: DisposeEvent | DisposeEvent[]
+    
+}
+
+export type Constructor = new (...args: any[]) => any;
+
+export type pathString = `?.${string}`;
+
+export type CustomElementName = string;
+export type CustomElementConstructorStaticMethodName = string;
+
+export interface AttrConfig<T = any> {
+  /**
+   * Type of the property value (JSON-serializable string format)
+   */
+  instanceOf?: 'Object' | 'String' | 'Number' | 'Boolean' | 'Array' 
+              | typeof Object | typeof String | typeof Number | typeof Boolean | typeof Array;
+
+  
+  /**
+   * Property name on the spawned class instance to map to
+   * Use '.' to map to the root object using assignGingerly
+   * Is optional.
+   * If not specified, we assume it is the key without the underscore first
+   * character, unless the key is _base in which case it assume mapsTo = "."
+   */
+  mapsTo?: 
+    | '.' 
+    | keyof T 
+    | pathString 
+    | `${pathString} +=`
+    | `${pathString} =!`
+    | `${pathString} -=`
+  
+  /**
+   * Parser to transform attribute string value
+   * - Function: Inline parser function (not JSON serializable)
+   * - String: Named parser reference (JSON serializable) - looks up in global parser registry (e.g., 'timestamp', 'csv')
+   * - Tuple: [CustomElementName, StaticMethodName] - looks up static method on custom element constructor (e.g., ['my-widget', 'parseSpecial'])
+   */
+  parser?: 
+    | ((attrValue: string | null) => any) 
+    | string 
+    | [CustomElementName, CustomElementConstructorStaticMethodName]
+  ;
+  
+  /**
+   * Default value to use when attribute is missing
+   * If defined, bypasses parser when attribute is not present
+   * If undefined, property is not added to initVals when attribute is missing
+   */
+  valIfNull?: any;
+  
+  /**
+   * Enable caching of parsed attribute values
+   * - 'shared': Cache and reuse the same parsed object (fast, but enhancements must not mutate)
+   * - 'cloned': Cache and return a structural clone (safer, but slower)
+   * Note: Parsers should be pure functions when using caching
+   */
+  parseCache?: 'shared' | 'cloned';
+  
+  // /**
+  //  * Whether to only read the initial value (true) or continue observing changes (false)
+  //  * Defaults to true (initial read only)
+  //  */
+  // initialOnly?: boolean;
+}
+
+export type AttrPatterns<T = any> = {
+  /**
+   * Base prefix for attribute names
+   */
+  base: string;
+
+  /**
+   * Configuration for the base pattern
+   */
+  _base?: AttrConfig<T>;
+} & {
+  // Provide autocomplete for all properties of T (optional)
+  [K in keyof T]?: string | AttrConfig<T>;
+} & {
+  // Provide autocomplete for underscore-prefixed config keys
+  [K in keyof T as `_${string & K}`]?: AttrConfig<T>;
+} & {
+  // Allow any other string keys for custom patterns
+  [key: string]: string | AttrConfig<T>;
+};
+
+
+export interface SpawnContext<T = any, TMountContext = any> {
+  config: EnhancementConfig<T>;
+  mountCtx?: TMountContext;
+}
+
+/**
+ * @deprecated Use EnhancementConfig instead
+ */
+export type IEnhancementRegistryItem<T = any> = EnhancementConfig<T>;
+
+/**
+ * Interface for the options passed to assignGingerly
+ */
+export interface IAssignGingerlyOptions {
+  registry?: typeof EnhancementRegistry | EnhancementRegistry;
+  bypassChecks?: boolean;
+}
+
+/**
+ * Event dispatched when enhancement configs are registered
+ */
+export declare class EnhancementRegisteredEvent extends Event {
+  static eventName: string;
+  config: EnhancementConfig | EnhancementConfig[];
+  constructor(config: EnhancementConfig | EnhancementConfig[]);
+}
+
+/**
+ * Base registry class for managing enhancement configurations
+ * Extends EventTarget to dispatch events when configs are registered
+ */
+export declare class EnhancementRegistry extends EventTarget {
+  private items;
+  push(items: EnhancementConfig | EnhancementConfig[]): void;
+  getItems(): EnhancementConfig[];
+  findBySymbol(symbol: symbol | string): EnhancementConfig | undefined;
+  findByEnhKey(enhKey: string | symbol): EnhancementConfig | undefined;
+}
+
+/**
+ * Constructor signature for ItemScope Manager classes
+ */
+export type ItemscopeManager<T = any> = {
+  new (element: HTMLElement, initVals?: Partial<T>): T;
+}
+
+/**
+ * Configuration for ItemScope Manager registration
+ */
+export interface ItemscopeManagerConfig<T = any> {
+  /**
+   * Manager class constructor
+   */
+  manager: ItemscopeManager<T>;
+  
+  /**
+   * Optional lifecycle method keys
+   * - dispose: Method name to call when manager is disposed
+   * - resolved: Property/event name indicating manager is ready
+   */
+  lifecycleKeys?: {
+    dispose?: string | symbol;
+    resolved?: string | symbol;
+  };
+}
+
+/**
+ * Registry for ItemScope Manager configurations
+ * Extends EventTarget to support lazy registration via events
+ */
+export declare class ItemscopeRegistry extends EventTarget {
+  define(name: string, config: ItemscopeManagerConfig): void;
+  get(name: string): ItemscopeManagerConfig | undefined;
+  whenDefined(name: string): Promise<void>;
+}
+
+/**
+ * Main assignGingerly function
+ */
+export declare function assignGingerly(
+  target: any,
+  source: Record<string | symbol, any>,
+  options?: IAssignGingerlyOptions
+): any;
+
+export default assignGingerly;
+
+export declare class ElementEnhancementGateway{
+  enh: ElementEnhancement;
+}
+
+export interface ElementEnhancement{
+  dispose(regItem: EnhancementConfig): void;
+}

package/types/be-a-beacon/types.d.ts

@@ -0,0 +1,3 @@
+export interface BeABeaconProps {
+    eventName: string;
+}

package/types/global.d.ts

@@ -0,0 +1,29 @@
+// Type declarations for Map.prototype.getOrInsertComputed and WeakMap.prototype.getOrInsertComputed
+// Feature is now supported in all modern browsers (Chrome 146+, Firefox 134+, Safari 18.2+)
+// See: https://web-platform-dx.github.io/web-features-explorer/features/getorinsert/
+
+interface Map<K, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsertComputed(key: K, insert: () => V): V;
+}
+
+interface WeakMap<K extends object, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsertComputed(key: K, insert: () => V): V;
+}
+
+interface HTMLTemplateElement {
+  remoteContent?: Node;
+}

package/types/id-generation/types.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for id-generation
+
+export interface GenIdsOptions {
+    //startCounter?: number;
+}
+
+export interface ParsedDataId {
+    name: string;
+    setName: boolean;
+    setItemprop: boolean;
+    setClass: boolean;
+    setPart: boolean;
+    setItemscope: boolean;
+}
+
+export interface ScopeInfo {
+    scopeElement: Element;
+    elementsToProcess: Element[];
+}
+
+export interface AttributeReplacement {
+    element: Element;
+    attributeName: string;
+    oldValue: string;
+    newValue: string;
+}