assign-gingerly 0.0.21 → 0.0.23

package/object-extension.js

@@ -1,4 +1,4 @@
-import assignGingerly, { EnhancementRegistry, getInstanceMap } from './assignGingerly.js';
+import assignGingerly, { EnhancementRegistry, ItemscopeRegistry, getInstanceMap } from './assignGingerly.js';
 import { parseWithAttrs } from './parseWithAttrs.js';
 /**
  * Normalizes lifecycleKeys to always return an object with dispose and resolved keys
@@ -34,6 +34,25 @@ if (typeof CustomElementRegistry !== 'undefined') {
         enumerable: false,
         configurable: true,
     });
+    /**
+     * Adds itemscopeRegistry to CustomElementRegistry prototype as a lazy getter
+     */
+    Object.defineProperty(CustomElementRegistry.prototype, 'itemscopeRegistry', {
+        get: function () {
+            // Create a new ItemscopeRegistry instance on first access and cache it
+            const registry = new ItemscopeRegistry();
+            // Replace the getter with the actual value
+            Object.defineProperty(this, 'itemscopeRegistry', {
+                value: registry,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            });
+            return registry;
+        },
+        enumerable: false,
+        configurable: true,
+    });
 }
 /**
  * Enhancement container class for Element.prototype.enh

package/object-extension.ts

@@ -1,4 +1,4 @@
-import assignGingerly, { EnhancementRegistry, IAssignGingerlyOptions, getInstanceMap, INSTANCE_MAP_GUID } from './assignGingerly.js';
+import assignGingerly, { EnhancementRegistry, ItemscopeRegistry, IAssignGingerlyOptions, getInstanceMap, INSTANCE_MAP_GUID } from './assignGingerly.js';
 import { parseWithAttrs } from './parseWithAttrs.js';
 
 /**
@@ -17,11 +17,12 @@ function normalizeLifecycleKeys(lifecycleKeys: true | { dispose?: string | symbo
 }
 
 /**
- * Extends the CustomElementRegistry interface to include enhancementRegistry
+ * Extends the CustomElementRegistry interface to include enhancementRegistry and itemscopeRegistry
  */
 declare global {
   interface CustomElementRegistry {
     enhancementRegistry: typeof EnhancementRegistry | EnhancementRegistry;
+    itemscopeRegistry: ItemscopeRegistry;
   }
   
   interface Element {
@@ -97,6 +98,26 @@ if (typeof CustomElementRegistry !== 'undefined') {
     enumerable: false,
     configurable: true,
   });
+
+  /**
+   * Adds itemscopeRegistry to CustomElementRegistry prototype as a lazy getter
+   */
+  Object.defineProperty(CustomElementRegistry.prototype, 'itemscopeRegistry', {
+    get: function () {
+      // Create a new ItemscopeRegistry instance on first access and cache it
+      const registry = new ItemscopeRegistry();
+      // Replace the getter with the actual value
+      Object.defineProperty(this, 'itemscopeRegistry', {
+        value: registry,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      });
+      return registry;
+    },
+    enumerable: false,
+    configurable: true,
+  });
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -58,12 +58,14 @@
   "scripts": {
     "serve": "node ./node_modules/spa-ssi/serve.js",
     "test": "playwright test",
-    "update": "ncu -u && npm install"
+    "update": "ncu -u && npm install",
+    "safari": "npx playwright wk http://localhost:8000",
+    "chrome": "npx playwright cr http://localhost:8000"
   },
   "devDependencies": {
-    "@playwright/test": "^1.58.2",
+    "@playwright/test": "1.59.0-alpha-2026-02-28",
     "spa-ssi": "0.0.27",
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.3.3",
     "typescript": "^5.9.3"
   }
 }

package/parseWithAttrs.js

@@ -23,35 +23,38 @@ function resolveParser(parserSpec) {
     if (typeof parserSpec === 'function') {
         return parserSpec;
     }
-    // String reference - resolve it
-    if (typeof parserSpec === 'string') {
-        // Check if it's a custom element reference (contains dot)
-        if (parserSpec.includes('.')) {
-            const dotIndex = parserSpec.indexOf('.');
-            const elementName = parserSpec.substring(0, dotIndex);
-            const methodName = parserSpec.substring(dotIndex + 1);
-            // Try custom element lookup
-            if (typeof customElements !== 'undefined') {
-                try {
-                    const ctr = customElements.get(elementName);
-                    if (ctr && typeof ctr[methodName] === 'function') {
-                        return ctr[methodName];
-                    }
-                }
-                catch (e) {
-                    // customElements.get might throw, fall through to registry
-                }
+    // Tuple [CustomElementName, StaticMethodName] - resolve custom element static method
+    if (Array.isArray(parserSpec)) {
+        const [elementName, methodName] = parserSpec;
+        if (typeof customElements === 'undefined') {
+            throw new Error(`Cannot resolve parser [${elementName}, ${methodName}]: customElements is not available`);
+        }
+        try {
+            const ctr = customElements.get(elementName);
+            if (!ctr) {
+                throw new Error(`Cannot resolve parser [${elementName}, ${methodName}]: custom element "${elementName}" not found`);
             }
-            // Fall through to global registry (allows dot notation in registry too)
+            if (typeof ctr[methodName] !== 'function') {
+                throw new Error(`Cannot resolve parser [${elementName}, ${methodName}]: static method "${methodName}" not found on custom element "${elementName}"`);
+            }
+            return ctr[methodName];
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('Cannot resolve parser')) {
+                throw e;
+            }
+            throw new Error(`Cannot resolve parser [${elementName}, ${methodName}]: ${e instanceof Error ? e.message : String(e)}`);
         }
-        // Try global registry
+    }
+    // String reference - resolve from global registry
+    if (typeof parserSpec === 'string') {
         const parser = globalParserRegistry.get(parserSpec);
         if (parser) {
             return parser;
         }
-        // Not found anywhere
-        throw new Error(`Parser "${parserSpec}" not found. ` +
-            `Check that it's registered in globalParserRegistry or exists as a static method on the custom element.`);
+        // Not found in registry
+        throw new Error(`Parser "${parserSpec}" not found in globalParserRegistry. ` +
+            `If you want to reference a custom element static method, use tuple syntax: ["element-name", "methodName"]`);
     }
     return undefined;
 }
@@ -71,6 +74,9 @@ function getCacheKey(config) {
     else if (typeof config.parser === 'string') {
         parserStr = `named:${config.parser}`;
     }
+    else if (Array.isArray(config.parser)) {
+        parserStr = `tuple:${config.parser[0]}.${config.parser[1]}`;
+    }
     else {
         parserStr = 'custom';
     }

package/parseWithAttrs.ts

@@ -17,7 +17,9 @@ const parseCache = new Map<string, Map<string, any>>();
  * @returns The resolved parser function
  * @throws Error if parser cannot be resolved
  */
-function resolveParser(parserSpec: ((v: string | null) => any) | string | undefined): ((v: string | null) => any) | undefined {
+function resolveParser(
+  parserSpec: ((v: string | null) => any) | string | [string, string] | undefined
+): ((v: string | null) => any) | undefined {
   // Undefined - no parser specified
   if (parserSpec === undefined) {
     return undefined;
@@ -28,39 +30,52 @@ function resolveParser(parserSpec: ((v: string | null) => any) | string | undefi
     return parserSpec;
   }
   
-  // String reference - resolve it
-  if (typeof parserSpec === 'string') {
-    // Check if it's a custom element reference (contains dot)
-    if (parserSpec.includes('.')) {
-      const dotIndex = parserSpec.indexOf('.');
-      const elementName = parserSpec.substring(0, dotIndex);
-      const methodName = parserSpec.substring(dotIndex + 1);
+  // Tuple [CustomElementName, StaticMethodName] - resolve custom element static method
+  if (Array.isArray(parserSpec)) {
+    const [elementName, methodName] = parserSpec;
+    
+    if (typeof customElements === 'undefined') {
+      throw new Error(
+        `Cannot resolve parser [${elementName}, ${methodName}]: customElements is not available`
+      );
+    }
+    
+    try {
+      const ctr = customElements.get(elementName);
+      if (!ctr) {
+        throw new Error(
+          `Cannot resolve parser [${elementName}, ${methodName}]: custom element "${elementName}" not found`
+        );
+      }
       
-      // Try custom element lookup
-      if (typeof customElements !== 'undefined') {
-        try {
-          const ctr = customElements.get(elementName);
-          if (ctr && typeof (ctr as any)[methodName] === 'function') {
-            return (ctr as any)[methodName];
-          }
-        } catch (e) {
-          // customElements.get might throw, fall through to registry
-        }
+      if (typeof (ctr as any)[methodName] !== 'function') {
+        throw new Error(
+          `Cannot resolve parser [${elementName}, ${methodName}]: static method "${methodName}" not found on custom element "${elementName}"`
+        );
       }
       
-      // Fall through to global registry (allows dot notation in registry too)
+      return (ctr as any)[methodName];
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith('Cannot resolve parser')) {
+        throw e;
+      }
+      throw new Error(
+        `Cannot resolve parser [${elementName}, ${methodName}]: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
-    
-    // Try global registry
+  }
+  
+  // String reference - resolve from global registry
+  if (typeof parserSpec === 'string') {
     const parser = globalParserRegistry.get(parserSpec);
     if (parser) {
       return parser;
     }
     
-    // Not found anywhere
+    // Not found in registry
     throw new Error(
-      `Parser "${parserSpec}" not found. ` +
-      `Check that it's registered in globalParserRegistry or exists as a static method on the custom element.`
+      `Parser "${parserSpec}" not found in globalParserRegistry. ` +
+      `If you want to reference a custom element static method, use tuple syntax: ["element-name", "methodName"]`
     );
   }
   
@@ -82,6 +97,8 @@ function getCacheKey(config: AttrConfig<any>): string {
     parserStr = 'builtin';
   } else if (typeof config.parser === 'string') {
     parserStr = `named:${config.parser}`;
+  } else if (Array.isArray(config.parser)) {
+    parserStr = `tuple:${config.parser[0]}.${config.parser[1]}`;
   } else {
     parserStr = 'custom';
   }

package/playwright-browser.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig, devices } from '@playwright/test';
+
+/**
+ * Playwright configuration for running tests in actual browser JavaScript engines.
+ * This configuration opens HTML test pages in real browsers instead of running
+ * tests in Node.js.
+ */
+export default defineConfig({
+  testDir: './tests-browser',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  
+  use: {
+    baseURL: 'http://localhost:8000',
+    trace: 'on-first-retry',
+  },
+
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] },
+    },
+  ],
+
+  // Start local web server before running tests
+  webServer: {
+    command: 'npm run serve',
+    port: 8000,
+    reuseExistingServer: !process.env.CI,
+  },
+});

package/playwright.config.ts

@@ -20,11 +20,11 @@ export default defineConfig({
   /* Opt out of parallel tests on CI. */
   workers: process.env.CI ? 1 : undefined,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: 'html',
+  reporter: [ ['html', { open: 'never' }] ],
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Base URL to use in actions like `await page.goto('/')`. */
-    baseURL: 'http://localhost:5173',
+    baseURL: 'http://localhost:8000',
   },
 
   /* Configure projects for major browsers */
@@ -34,21 +34,21 @@ export default defineConfig({
       use: { ...devices['Desktop Chrome'] },
     },
 
-    {
-      name: 'firefox',
-      use: { ...devices['Desktop Firefox'] },
-    },
+    // {
+    //   name: 'firefox',
+    //   use: { ...devices['Desktop Firefox'] },
+    // },
 
-    {
-      name: 'webkit',
-      use: { ...devices['Desktop Safari'] },
-    },
+    // {
+    //   name: 'webkit',
+    //   use: { ...devices['Desktop Safari'] },
+    // },
   ],
 
   /* Run your local dev server before starting the tests */
-  // webServer: {
-  //   command: 'npm run dev',
-  //   url: 'http://localhost:5173',
-  //   reuseExistingServer: !process.env.CI,
-  // },
+  webServer: {
+    command: 'npm run serve',
+    port: 8000,
+    reuseExistingServer: !process.env.CI,
+  },
 });

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

@@ -66,6 +66,9 @@ 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)
@@ -92,12 +95,14 @@ export interface AttrConfig<T = any> {
   /**
    * Parser to transform attribute string value
    * - Function: Inline parser function (not JSON serializable)
-   * - String: Named parser reference (JSON serializable)
-   *   - Simple name: Looks up in global parser registry (e.g., 'timestamp', 'csv')
-   *   - Dot notation: Looks up static method on custom element (e.g., 'my-widget.parseSpecial')
-   *     Falls back to global registry if custom element not found
+   * - 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;
+  parser?: 
+    | ((attrValue: string | null) => any) 
+    | string 
+    | [CustomElementName, CustomElementConstructorStaticMethodName]
+  ;
   
   /**
    * Default value to use when attribute is missing
@@ -161,10 +166,20 @@ export interface IAssignGingerlyOptions {
   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 {
+export declare class EnhancementRegistry extends EventTarget {
   private items;
   push(items: EnhancementConfig | EnhancementConfig[]): void;
   getItems(): EnhancementConfig[];
@@ -172,6 +187,43 @@ export declare class EnhancementRegistry {
   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
  */

package/types/global.d.ts

@@ -23,3 +23,7 @@ interface WeakMap<K extends object, V> {
    */
   getOrInsertComputed(key: K, insert: () => V): V;
 }
+
+interface HTMLTemplateElement {
+  remoteContent?: Node;
+}