mount-observer 0.1.29 → 0.1.30

package/handlers/EMCParserScript.js

@@ -60,7 +60,6 @@ export class EMCParserScriptHandler extends EvtRt {
                 detail: { parserName },
                 bubbles: true
             }));
-            console.log(`Registered parser "${parserName}" from ${src}`);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/handlers/EMCParserScript.ts

@@ -76,8 +76,6 @@ export class EMCParserScriptHandler extends EvtRt {
                 bubbles: true
             }));
             
-            console.log(`Registered parser "${parserName}" from ${src}`);
-            
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error(`Failed to load parser "${parserName}" from "${src}":`, errorMessage);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mount-observer",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",
   "dependencies": {
-    "assign-gingerly": "0.0.27",
+    "assign-gingerly": "0.0.28",
     "id-generation": "0.0.4"
   },
   "devDependencies": {

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

@@ -112,7 +112,7 @@ export type ParserFunction<T = any> =
   | ((attrValue: string | null) => any)
   | ((attrValue: string | null, context?: ParserContext<T>) => any);
 
-export interface AttrConfig<T = any> {
+export interface AttrConfig<T = unknown, TParserConfig = unknown> {
   /**
    * Type of the property value (JSON-serializable string format)
    */
@@ -152,6 +152,12 @@ export interface AttrConfig<T = any> {
     | ParserFunction<T>
     | string
   ;
+
+  /**
+   * configuration information needed by a custom parser to properly
+   * parse the attribute.
+   */
+  parserConfig?: TParserConfig;
   
   /**
    * Default value to use when attribute is missing

package/types/do-invoke/types.d.ts

@@ -0,0 +1,28 @@
+export interface Specifier {
+    selector?: string;
+    prop?: string;
+}
+
+export interface EndUserProps{
+    invokeParamSets: Array<InvokingParameters>,
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    rawStatements: Array<string>,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP  = Promise<PAP>
+
+export interface Actions{
+    hydrate(self: AP): ProPAP;
+}
+
+export interface InvokingParameters {
+    remoteSpecifier: Specifier,
+    localEventType?: string,
+}

package/types/nested-regex-groups/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Type definitions for nested-regex-groups
+ * 
+ * These types can be imported in JavaScript files using JSDoc:
+ * @example
+ * // In JavaScript:
+ * /** @type {import('nested-regex-groups').ParseResult} *\/
+ * const result = parser('input');
+ */
+
+/**
+ * Result of a successful parse operation
+ */
+export interface ParseSuccess<T = any> {
+  success: true;
+  value: T;
+  matched: string;
+  rest: string;
+}
+
+/**
+ * Result of a failed parse operation
+ */
+export interface ParseFailure {
+  success: false;
+  error: string;
+  position?: number;
+}
+
+/**
+ * Union type for parse results
+ */
+export type ParseResult<T = any> = ParseSuccess<T> | ParseFailure;
+
+/**
+ * A pattern definition with metadata (internal use with compiled RegExp)
+ */
+export interface ParsePattern {
+  name: string;
+  regex: RegExp;
+  description?: string;
+  /**
+   * Optional mapping from regex group names to dot-notation paths
+   * Example: { user_name: 'user.name', user_domain: 'user.domain' }
+   */
+  groupMap?: Record<string, string>;
+}
+
+/**
+ * Pattern configuration for parsePatterns and parsePattern functions
+ * Used when loading patterns from JSON or defining patterns as strings
+ */
+export interface PatternConfig {
+  name: string;
+  pattern: string;
+  description?: string;
+}
+
+/**
+ * Options for nestedRegex function
+ */
+export interface NestedRegexOptions {
+  /**
+   * Optional name for the pattern (used in error messages)
+   */
+  name?: string;
+  /**
+   * Optional mapping from regex group names to dot-notation paths
+   * Example: { user_name: 'user.name', user_domain: 'user.domain' }
+   */
+  groupMap?: Record<string, string>;
+}
+
+/**
+ * Options for creating a parser
+ */
+export interface ParserOptions {
+  /**
+   * If true, returns detailed error information when no pattern matches
+   */
+  verbose?: boolean;
+}
+
+/**
+ * Result type for parsing multiple statements
+ */
+export interface StatementsResult<T = any> {
+  success: boolean;
+  statements: Array<{
+    pattern?: string;
+    value?: T;
+    error?: string;
+    matched?: string;
+  }>;
+}