@walkeros/explorer 3.0.1 → 3.0.2

package/dist/utils/format-code.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Format code using Prettier
+ *
+ * @param code - The code to format
+ * @param language - The language (javascript, typescript, json, html, css)
+ * @returns Formatted code, or original code if formatting fails
+ */
+export declare function formatCode(code: string, language: string): Promise<string>;
+//# sourceMappingURL=format-code.d.ts.map

package/dist/utils/format-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-code.d.ts","sourceRoot":"","sources":["../../src/utils/format-code.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAsEjB"}

package/dist/utils/format-code.js

@@ -0,0 +1,77 @@
+import * as prettier from 'prettier/standalone';
+import prettierBabel from 'prettier/plugins/babel';
+import prettierEstree from 'prettier/plugins/estree';
+import prettierTypescript from 'prettier/plugins/typescript';
+import prettierHtml from 'prettier/plugins/html';
+/**
+ * Format code using Prettier
+ *
+ * @param code - The code to format
+ * @param language - The language (javascript, typescript, json, html, css)
+ * @returns Formatted code, or original code if formatting fails
+ */
+export async function formatCode(code, language) {
+    try {
+        let formatted;
+        switch (language) {
+            case 'javascript':
+            case 'js': {
+                // Wrap bare objects in parens so Prettier can parse them
+                // Skip one-liners — they're intentionally compact
+                const isBareObject = code.trimStart().startsWith('{') && code.includes('\n');
+                const input = isBareObject ? `(${code})` : code;
+                formatted = await prettier.format(input, {
+                    parser: 'babel',
+                    plugins: [prettierBabel, prettierEstree],
+                    semi: true,
+                    singleQuote: true,
+                    trailingComma: 'all',
+                });
+                if (isBareObject) {
+                    // Unwrap: remove leading "(" and trailing ");\n"
+                    formatted = formatted.replace(/^\(/, '').replace(/\);?\s*$/, '');
+                }
+                break;
+            }
+            case 'typescript':
+            case 'ts':
+            case 'tsx':
+                formatted = await prettier.format(code, {
+                    parser: 'typescript',
+                    plugins: [prettierTypescript, prettierEstree],
+                    semi: true,
+                    singleQuote: true,
+                    trailingComma: 'all',
+                });
+                break;
+            case 'json':
+                // Use native JSON for simplicity
+                const parsed = JSON.parse(code);
+                formatted = JSON.stringify(parsed, null, 2);
+                break;
+            case 'html':
+                formatted = await prettier.format(code, {
+                    parser: 'html',
+                    plugins: [prettierHtml],
+                    htmlWhitespaceSensitivity: 'css',
+                });
+                break;
+            case 'css':
+            case 'scss':
+                formatted = await prettier.format(code, {
+                    parser: 'css',
+                    plugins: [prettierHtml],
+                });
+                break;
+            default:
+                // Unsupported language, return original
+                return code;
+        }
+        // Trim trailing whitespace/newlines
+        return formatted.trim();
+    }
+    catch (error) {
+        return code;
+    }
+}
+//# sourceMappingURL=format-code.js.map

package/dist/utils/format-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-code.js","sourceRoot":"","sources":["../../src/utils/format-code.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAChD,OAAO,aAAa,MAAM,wBAAwB,CAAC;AACnD,OAAO,cAAc,MAAM,yBAAyB,CAAC;AACrD,OAAO,kBAAkB,MAAM,6BAA6B,CAAC;AAC7D,OAAO,YAAY,MAAM,uBAAuB,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,IAAY,EACZ,QAAgB;IAEhB,IAAI,CAAC;QACH,IAAI,SAAiB,CAAC;QAEtB,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,YAAY,CAAC;YAClB,KAAK,IAAI,CAAC,CAAC,CAAC;gBACV,yDAAyD;gBACzD,kDAAkD;gBAClD,MAAM,YAAY,GAChB,IAAI,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAC1D,MAAM,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;gBAChD,SAAS,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE;oBACvC,MAAM,EAAE,OAAO;oBACf,OAAO,EAAE,CAAC,aAAa,EAAE,cAAc,CAAC;oBACxC,IAAI,EAAE,IAAI;oBACV,WAAW,EAAE,IAAI;oBACjB,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAC;gBACH,IAAI,YAAY,EAAE,CAAC;oBACjB,iDAAiD;oBACjD,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;gBACnE,CAAC;gBACD,MAAM;YACR,CAAC;YAED,KAAK,YAAY,CAAC;YAClB,KAAK,IAAI,CAAC;YACV,KAAK,KAAK;gBACR,SAAS,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;oBACtC,MAAM,EAAE,YAAY;oBACpB,OAAO,EAAE,CAAC,kBAAkB,EAAE,cAAc,CAAC;oBAC7C,IAAI,EAAE,IAAI;oBACV,WAAW,EAAE,IAAI;oBACjB,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAC;gBACH,MAAM;YAER,KAAK,MAAM;gBACT,iCAAiC;gBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAChC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBAC5C,MAAM;YAER,KAAK,MAAM;gBACT,SAAS,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;oBACtC,MAAM,EAAE,MAAM;oBACd,OAAO,EAAE,CAAC,YAAY,CAAC;oBACvB,yBAAyB,EAAE,KAAK;iBACjC,CAAC,CAAC;gBACH,MAAM;YAER,KAAK,KAAK,CAAC;YACX,KAAK,MAAM;gBACT,SAAS,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;oBACtC,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE,CAAC,YAAY,CAAC;iBACxB,CAAC,CAAC;gBACH,MAAM;YAER;gBACE,wCAAwC;gBACxC,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,oCAAoC;QACpC,OAAO,SAAS,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/utils/mapping-context-detector.d.ts

@@ -0,0 +1,17 @@
+export interface MappingContext {
+    entity: string;
+    action: string;
+}
+/**
+ * Detect the entity/action context from a JSON path that includes "mapping".
+ *
+ * The mapping structure in flow.json is:
+ * flows.<name>.destinations.<name>.mapping.<entity>.<action>.<...>
+ *
+ * After the "mapping" key, the next two segments are entity and action.
+ *
+ * @param pathSegments - JSON path segments from root to cursor position
+ * @returns Entity and action if inside a mapping rule, null otherwise
+ */
+export declare function detectMappingContext(pathSegments: string[]): MappingContext | null;
+//# sourceMappingURL=mapping-context-detector.d.ts.map

package/dist/utils/mapping-context-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping-context-detector.d.ts","sourceRoot":"","sources":["../../src/utils/mapping-context-detector.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EAAE,GACrB,cAAc,GAAG,IAAI,CAUvB"}

package/dist/utils/mapping-context-detector.js

@@ -0,0 +1,22 @@
+/**
+ * Detect the entity/action context from a JSON path that includes "mapping".
+ *
+ * The mapping structure in flow.json is:
+ * flows.<name>.destinations.<name>.mapping.<entity>.<action>.<...>
+ *
+ * After the "mapping" key, the next two segments are entity and action.
+ *
+ * @param pathSegments - JSON path segments from root to cursor position
+ * @returns Entity and action if inside a mapping rule, null otherwise
+ */
+export function detectMappingContext(pathSegments) {
+    const mappingIndex = pathSegments.indexOf('mapping');
+    if (mappingIndex === -1)
+        return null;
+    const entity = pathSegments[mappingIndex + 1];
+    const action = pathSegments[mappingIndex + 2];
+    if (!entity || !action)
+        return null;
+    return { entity, action };
+}
+//# sourceMappingURL=mapping-context-detector.js.map

package/dist/utils/mapping-context-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping-context-detector.js","sourceRoot":"","sources":["../../src/utils/mapping-context-detector.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAClC,YAAsB;IAEtB,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACrD,IAAI,YAAY,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAErC,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;IAC9C,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;IAE9C,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEpC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC5B,CAAC"}

package/dist/utils/monaco-context-types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Monaco Editor Context Type Templates
+ *
+ * Hand-crafted global namespace declarations for function contexts.
+ * These provide full TypeScript IntelliSense in Monaco Editor without
+ * requiring import statements.
+ *
+ * Extracted from @walkeros/core types and simplified for editor use.
+ */
+/**
+ * Type template for 'fn' context (transformation functions)
+ *
+ * Provides types for:
+ * - value: WalkerOS.DeepPartialEvent | unknown
+ * - mapping: Mapping.Value
+ * - options: Mapping.Options
+ */
+export declare const FN_CONTEXT_TYPES = "\n// WalkerOS Core Types\ndeclare namespace WalkerOS {\n  // Utility types\n  type DeepPartial<T> = {\n    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];\n  };\n\n  type PromiseOrValue<T> = T | Promise<T>;\n\n  // Property types\n  type PropertyType = boolean | string | number | {\n    [key: string]: Property;\n  };\n\n  type Property = PropertyType | Array<PropertyType>;\n\n  interface Properties {\n    [key: string]: Property | undefined;\n  }\n\n  interface OrderedProperties {\n    [key: string]: [Property, number] | undefined;\n  }\n\n  // Consent\n  interface Consent {\n    [name: string]: boolean;\n  }\n\n  // User\n  interface User extends Properties {\n    id?: string;\n    device?: string;\n    session?: string;\n    hash?: string;\n    address?: string;\n    email?: string;\n    phone?: string;\n    userAgent?: string;\n    browser?: string;\n    browserVersion?: string;\n    deviceType?: string;\n    language?: string;\n    country?: string;\n    region?: string;\n    city?: string;\n    zip?: string;\n    timezone?: string;\n    os?: string;\n    osVersion?: string;\n    screenSize?: string;\n    ip?: string;\n    internal?: boolean;\n  }\n\n  // Version\n  interface Version extends Properties {\n    source: string;\n    tagging: number;\n  }\n\n  // Source\n  type SourceType = 'web' | 'server' | 'app' | 'other' | string;\n\n  interface Source extends Properties {\n    type: SourceType;\n    id: string;\n    previous_id: string;\n  }\n\n  // Entity\n  type Entities = Array<Entity>;\n\n  interface Entity {\n    entity: string;\n    data: Properties;\n    nested: Entities;\n    context: OrderedProperties;\n  }\n\n  // Event\n  interface Event {\n    name: string;\n    data: Properties;\n    context: OrderedProperties;\n    globals: Properties;\n    custom: Properties;\n    user: User;\n    nested: Entities;\n    consent: Consent;\n    id: string;\n    trigger: string;\n    entity: string;\n    action: string;\n    timestamp: number;\n    timing: number;\n    group: string;\n    count: number;\n    version: Version;\n    source: Source;\n  }\n\n  type DeepPartialEvent = DeepPartial<Event>;\n}\n\n// Mapping Types\ndeclare namespace Mapping {\n  type ValueType = string | ValueConfig;\n  type Value = ValueType | Array<ValueType>;\n  type Values = Array<Value>;\n\n  interface ValueConfig {\n    condition?: Condition;\n    consent?: WalkerOS.Consent;\n    fn?: Fn;\n    key?: string;\n    loop?: Loop;\n    map?: Map;\n    set?: Value[];\n    validate?: Validate;\n    value?: WalkerOS.PropertyType;\n  }\n\n  type Loop = [Value, Value];\n\n  type Map = {\n    [key: string]: Value;\n  };\n\n  interface Options {\n    consent?: WalkerOS.Consent;\n    collector?: Collector.Instance;\n    props?: unknown;\n  }\n\n  type Condition = (\n    value: WalkerOS.DeepPartialEvent | unknown,\n    mapping?: Value,\n    collector?: Collector.Instance\n  ) => WalkerOS.PromiseOrValue<boolean>;\n\n  type Fn = (\n    value: WalkerOS.DeepPartialEvent | unknown,\n    mapping: Value,\n    options: Options\n  ) => WalkerOS.PromiseOrValue<WalkerOS.Property | unknown>;\n\n  type Validate = (value?: unknown) => WalkerOS.PromiseOrValue<boolean>;\n}\n\n// Collector Types (minimal for fn context)\ndeclare namespace Collector {\n  interface Instance {\n    push: any;\n    command: any;\n    allowed: boolean;\n    config: any;\n    consent: WalkerOS.Consent;\n    count: number;\n    custom: WalkerOS.Properties;\n    globals: WalkerOS.Properties;\n    group: string;\n    queue: any[];\n    round: number;\n    session: any;\n    timing: number;\n    user: WalkerOS.User;\n    version: string;\n    [key: string]: any;\n  }\n}\n\n// Parameter declarations for fn context\ndeclare const value: WalkerOS.DeepPartialEvent | unknown;\ndeclare const mapping: Mapping.Value;\ndeclare const options: Mapping.Options;\n";
+/**
+ * Type template for 'condition' context (conditional functions)
+ *
+ * Provides types for:
+ * - value: WalkerOS.DeepPartialEvent | unknown
+ * - mapping: Mapping.Value
+ * - collector: Collector.Instance | undefined
+ */
+export declare const CONDITION_CONTEXT_TYPES = "\n// WalkerOS Core Types\ndeclare namespace WalkerOS {\n  // Utility types\n  type DeepPartial<T> = {\n    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];\n  };\n\n  type PromiseOrValue<T> = T | Promise<T>;\n\n  // Property types\n  type PropertyType = boolean | string | number | {\n    [key: string]: Property;\n  };\n\n  type Property = PropertyType | Array<PropertyType>;\n\n  interface Properties {\n    [key: string]: Property | undefined;\n  }\n\n  interface OrderedProperties {\n    [key: string]: [Property, number] | undefined;\n  }\n\n  // Consent\n  interface Consent {\n    [name: string]: boolean;\n  }\n\n  // User\n  interface User extends Properties {\n    id?: string;\n    device?: string;\n    session?: string;\n    hash?: string;\n    address?: string;\n    email?: string;\n    phone?: string;\n    userAgent?: string;\n    browser?: string;\n    browserVersion?: string;\n    deviceType?: string;\n    language?: string;\n    country?: string;\n    region?: string;\n    city?: string;\n    zip?: string;\n    timezone?: string;\n    os?: string;\n    osVersion?: string;\n    screenSize?: string;\n    ip?: string;\n    internal?: boolean;\n  }\n\n  // Version\n  interface Version extends Properties {\n    source: string;\n    tagging: number;\n  }\n\n  // Source\n  type SourceType = 'web' | 'server' | 'app' | 'other' | string;\n\n  interface Source extends Properties {\n    type: SourceType;\n    id: string;\n    previous_id: string;\n  }\n\n  // Entity\n  type Entities = Array<Entity>;\n\n  interface Entity {\n    entity: string;\n    data: Properties;\n    nested: Entities;\n    context: OrderedProperties;\n  }\n\n  // Event\n  interface Event {\n    name: string;\n    data: Properties;\n    context: OrderedProperties;\n    globals: Properties;\n    custom: Properties;\n    user: User;\n    nested: Entities;\n    consent: Consent;\n    id: string;\n    trigger: string;\n    entity: string;\n    action: string;\n    timestamp: number;\n    timing: number;\n    group: string;\n    count: number;\n    version: Version;\n    source: Source;\n  }\n\n  type DeepPartialEvent = DeepPartial<Event>;\n}\n\n// Mapping Types\ndeclare namespace Mapping {\n  type ValueType = string | ValueConfig;\n  type Value = ValueType | Array<ValueType>;\n\n  interface ValueConfig {\n    condition?: Condition;\n    consent?: WalkerOS.Consent;\n    fn?: Fn;\n    key?: string;\n    loop?: Loop;\n    map?: Map;\n    set?: Value[];\n    validate?: Validate;\n    value?: WalkerOS.PropertyType;\n  }\n\n  type Loop = [Value, Value];\n\n  type Map = {\n    [key: string]: Value;\n  };\n\n  type Condition = (\n    value: WalkerOS.DeepPartialEvent | unknown,\n    mapping?: Value,\n    collector?: Collector.Instance\n  ) => WalkerOS.PromiseOrValue<boolean>;\n\n  type Fn = (\n    value: WalkerOS.DeepPartialEvent | unknown,\n    mapping: Value,\n    options: any\n  ) => WalkerOS.PromiseOrValue<WalkerOS.Property | unknown>;\n\n  type Validate = (value?: unknown) => WalkerOS.PromiseOrValue<boolean>;\n}\n\n// Collector Types (full interface for condition context)\ndeclare namespace Collector {\n  interface SessionData extends WalkerOS.Properties {\n    isStart: boolean;\n    storage: boolean;\n    id?: string;\n    start?: number;\n    marketing?: true;\n    updated?: number;\n    isNew?: boolean;\n    device?: string;\n    count?: number;\n    runs?: number;\n  }\n\n  interface Config {\n    run?: boolean;\n    tagging: number;\n    globalsStatic: WalkerOS.Properties;\n    sessionStatic: Partial<SessionData>;\n    verbose: boolean;\n    onError?: any;\n    onLog?: any;\n  }\n\n  interface Instance {\n    push: any;\n    command: any;\n    allowed: boolean;\n    config: Config;\n    consent: WalkerOS.Consent;\n    count: number;\n    custom: WalkerOS.Properties;\n    sources: any;\n    destinations: any;\n    globals: WalkerOS.Properties;\n    group: string;\n    hooks: any;\n    on: any;\n    queue: any[];\n    round: number;\n    session: undefined | SessionData;\n    timing: number;\n    user: WalkerOS.User;\n    version: string;\n  }\n}\n\n// Parameter declarations for condition context\ndeclare const value: WalkerOS.DeepPartialEvent | unknown;\ndeclare const mapping: Mapping.Value;\ndeclare const collector: Collector.Instance | undefined;\n";
+/**
+ * Type template for 'validate' context (validation functions)
+ *
+ * Provides types for:
+ * - value: unknown
+ */
+export declare const VALIDATE_CONTEXT_TYPES = "\n// Parameter declaration for validate context\ndeclare const value: unknown;\n";
+/**
+ * Get the type template for a specific function context
+ */
+export declare function getContextTypes(contextType: 'fn' | 'condition' | 'validate'): string;
+//# sourceMappingURL=monaco-context-types.d.ts.map

package/dist/utils/monaco-context-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-context-types.d.ts","sourceRoot":"","sources":["../../src/utils/monaco-context-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,0xHAiL5B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,wtIAoMnC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,qFAGlC,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,IAAI,GAAG,WAAW,GAAG,UAAU,GAC3C,MAAM,CAWR"}

package/dist/utils/monaco-context-types.js

@@ -0,0 +1,426 @@
+/**
+ * Monaco Editor Context Type Templates
+ *
+ * Hand-crafted global namespace declarations for function contexts.
+ * These provide full TypeScript IntelliSense in Monaco Editor without
+ * requiring import statements.
+ *
+ * Extracted from @walkeros/core types and simplified for editor use.
+ */
+/**
+ * Type template for 'fn' context (transformation functions)
+ *
+ * Provides types for:
+ * - value: WalkerOS.DeepPartialEvent | unknown
+ * - mapping: Mapping.Value
+ * - options: Mapping.Options
+ */
+export const FN_CONTEXT_TYPES = `
+// WalkerOS Core Types
+declare namespace WalkerOS {
+  // Utility types
+  type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+  };
+
+  type PromiseOrValue<T> = T | Promise<T>;
+
+  // Property types
+  type PropertyType = boolean | string | number | {
+    [key: string]: Property;
+  };
+
+  type Property = PropertyType | Array<PropertyType>;
+
+  interface Properties {
+    [key: string]: Property | undefined;
+  }
+
+  interface OrderedProperties {
+    [key: string]: [Property, number] | undefined;
+  }
+
+  // Consent
+  interface Consent {
+    [name: string]: boolean;
+  }
+
+  // User
+  interface User extends Properties {
+    id?: string;
+    device?: string;
+    session?: string;
+    hash?: string;
+    address?: string;
+    email?: string;
+    phone?: string;
+    userAgent?: string;
+    browser?: string;
+    browserVersion?: string;
+    deviceType?: string;
+    language?: string;
+    country?: string;
+    region?: string;
+    city?: string;
+    zip?: string;
+    timezone?: string;
+    os?: string;
+    osVersion?: string;
+    screenSize?: string;
+    ip?: string;
+    internal?: boolean;
+  }
+
+  // Version
+  interface Version extends Properties {
+    source: string;
+    tagging: number;
+  }
+
+  // Source
+  type SourceType = 'web' | 'server' | 'app' | 'other' | string;
+
+  interface Source extends Properties {
+    type: SourceType;
+    id: string;
+    previous_id: string;
+  }
+
+  // Entity
+  type Entities = Array<Entity>;
+
+  interface Entity {
+    entity: string;
+    data: Properties;
+    nested: Entities;
+    context: OrderedProperties;
+  }
+
+  // Event
+  interface Event {
+    name: string;
+    data: Properties;
+    context: OrderedProperties;
+    globals: Properties;
+    custom: Properties;
+    user: User;
+    nested: Entities;
+    consent: Consent;
+    id: string;
+    trigger: string;
+    entity: string;
+    action: string;
+    timestamp: number;
+    timing: number;
+    group: string;
+    count: number;
+    version: Version;
+    source: Source;
+  }
+
+  type DeepPartialEvent = DeepPartial<Event>;
+}
+
+// Mapping Types
+declare namespace Mapping {
+  type ValueType = string | ValueConfig;
+  type Value = ValueType | Array<ValueType>;
+  type Values = Array<Value>;
+
+  interface ValueConfig {
+    condition?: Condition;
+    consent?: WalkerOS.Consent;
+    fn?: Fn;
+    key?: string;
+    loop?: Loop;
+    map?: Map;
+    set?: Value[];
+    validate?: Validate;
+    value?: WalkerOS.PropertyType;
+  }
+
+  type Loop = [Value, Value];
+
+  type Map = {
+    [key: string]: Value;
+  };
+
+  interface Options {
+    consent?: WalkerOS.Consent;
+    collector?: Collector.Instance;
+    props?: unknown;
+  }
+
+  type Condition = (
+    value: WalkerOS.DeepPartialEvent | unknown,
+    mapping?: Value,
+    collector?: Collector.Instance
+  ) => WalkerOS.PromiseOrValue<boolean>;
+
+  type Fn = (
+    value: WalkerOS.DeepPartialEvent | unknown,
+    mapping: Value,
+    options: Options
+  ) => WalkerOS.PromiseOrValue<WalkerOS.Property | unknown>;
+
+  type Validate = (value?: unknown) => WalkerOS.PromiseOrValue<boolean>;
+}
+
+// Collector Types (minimal for fn context)
+declare namespace Collector {
+  interface Instance {
+    push: any;
+    command: any;
+    allowed: boolean;
+    config: any;
+    consent: WalkerOS.Consent;
+    count: number;
+    custom: WalkerOS.Properties;
+    globals: WalkerOS.Properties;
+    group: string;
+    queue: any[];
+    round: number;
+    session: any;
+    timing: number;
+    user: WalkerOS.User;
+    version: string;
+    [key: string]: any;
+  }
+}
+
+// Parameter declarations for fn context
+declare const value: WalkerOS.DeepPartialEvent | unknown;
+declare const mapping: Mapping.Value;
+declare const options: Mapping.Options;
+`;
+/**
+ * Type template for 'condition' context (conditional functions)
+ *
+ * Provides types for:
+ * - value: WalkerOS.DeepPartialEvent | unknown
+ * - mapping: Mapping.Value
+ * - collector: Collector.Instance | undefined
+ */
+export const CONDITION_CONTEXT_TYPES = `
+// WalkerOS Core Types
+declare namespace WalkerOS {
+  // Utility types
+  type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+  };
+
+  type PromiseOrValue<T> = T | Promise<T>;
+
+  // Property types
+  type PropertyType = boolean | string | number | {
+    [key: string]: Property;
+  };
+
+  type Property = PropertyType | Array<PropertyType>;
+
+  interface Properties {
+    [key: string]: Property | undefined;
+  }
+
+  interface OrderedProperties {
+    [key: string]: [Property, number] | undefined;
+  }
+
+  // Consent
+  interface Consent {
+    [name: string]: boolean;
+  }
+
+  // User
+  interface User extends Properties {
+    id?: string;
+    device?: string;
+    session?: string;
+    hash?: string;
+    address?: string;
+    email?: string;
+    phone?: string;
+    userAgent?: string;
+    browser?: string;
+    browserVersion?: string;
+    deviceType?: string;
+    language?: string;
+    country?: string;
+    region?: string;
+    city?: string;
+    zip?: string;
+    timezone?: string;
+    os?: string;
+    osVersion?: string;
+    screenSize?: string;
+    ip?: string;
+    internal?: boolean;
+  }
+
+  // Version
+  interface Version extends Properties {
+    source: string;
+    tagging: number;
+  }
+
+  // Source
+  type SourceType = 'web' | 'server' | 'app' | 'other' | string;
+
+  interface Source extends Properties {
+    type: SourceType;
+    id: string;
+    previous_id: string;
+  }
+
+  // Entity
+  type Entities = Array<Entity>;
+
+  interface Entity {
+    entity: string;
+    data: Properties;
+    nested: Entities;
+    context: OrderedProperties;
+  }
+
+  // Event
+  interface Event {
+    name: string;
+    data: Properties;
+    context: OrderedProperties;
+    globals: Properties;
+    custom: Properties;
+    user: User;
+    nested: Entities;
+    consent: Consent;
+    id: string;
+    trigger: string;
+    entity: string;
+    action: string;
+    timestamp: number;
+    timing: number;
+    group: string;
+    count: number;
+    version: Version;
+    source: Source;
+  }
+
+  type DeepPartialEvent = DeepPartial<Event>;
+}
+
+// Mapping Types
+declare namespace Mapping {
+  type ValueType = string | ValueConfig;
+  type Value = ValueType | Array<ValueType>;
+
+  interface ValueConfig {
+    condition?: Condition;
+    consent?: WalkerOS.Consent;
+    fn?: Fn;
+    key?: string;
+    loop?: Loop;
+    map?: Map;
+    set?: Value[];
+    validate?: Validate;
+    value?: WalkerOS.PropertyType;
+  }
+
+  type Loop = [Value, Value];
+
+  type Map = {
+    [key: string]: Value;
+  };
+
+  type Condition = (
+    value: WalkerOS.DeepPartialEvent | unknown,
+    mapping?: Value,
+    collector?: Collector.Instance
+  ) => WalkerOS.PromiseOrValue<boolean>;
+
+  type Fn = (
+    value: WalkerOS.DeepPartialEvent | unknown,
+    mapping: Value,
+    options: any
+  ) => WalkerOS.PromiseOrValue<WalkerOS.Property | unknown>;
+
+  type Validate = (value?: unknown) => WalkerOS.PromiseOrValue<boolean>;
+}
+
+// Collector Types (full interface for condition context)
+declare namespace Collector {
+  interface SessionData extends WalkerOS.Properties {
+    isStart: boolean;
+    storage: boolean;
+    id?: string;
+    start?: number;
+    marketing?: true;
+    updated?: number;
+    isNew?: boolean;
+    device?: string;
+    count?: number;
+    runs?: number;
+  }
+
+  interface Config {
+    run?: boolean;
+    tagging: number;
+    globalsStatic: WalkerOS.Properties;
+    sessionStatic: Partial<SessionData>;
+    verbose: boolean;
+    onError?: any;
+    onLog?: any;
+  }
+
+  interface Instance {
+    push: any;
+    command: any;
+    allowed: boolean;
+    config: Config;
+    consent: WalkerOS.Consent;
+    count: number;
+    custom: WalkerOS.Properties;
+    sources: any;
+    destinations: any;
+    globals: WalkerOS.Properties;
+    group: string;
+    hooks: any;
+    on: any;
+    queue: any[];
+    round: number;
+    session: undefined | SessionData;
+    timing: number;
+    user: WalkerOS.User;
+    version: string;
+  }
+}
+
+// Parameter declarations for condition context
+declare const value: WalkerOS.DeepPartialEvent | unknown;
+declare const mapping: Mapping.Value;
+declare const collector: Collector.Instance | undefined;
+`;
+/**
+ * Type template for 'validate' context (validation functions)
+ *
+ * Provides types for:
+ * - value: unknown
+ */
+export const VALIDATE_CONTEXT_TYPES = `
+// Parameter declaration for validate context
+declare const value: unknown;
+`;
+/**
+ * Get the type template for a specific function context
+ */
+export function getContextTypes(contextType) {
+    switch (contextType) {
+        case 'fn':
+            return FN_CONTEXT_TYPES;
+        case 'condition':
+            return CONDITION_CONTEXT_TYPES;
+        case 'validate':
+            return VALIDATE_CONTEXT_TYPES;
+        default:
+            return '';
+    }
+}
+//# sourceMappingURL=monaco-context-types.js.map

package/dist/utils/monaco-context-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-context-types.js","sourceRoot":"","sources":["../../src/utils/monaco-context-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiL/B,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMtC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;CAGrC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,WAA4C;IAE5C,QAAQ,WAAW,EAAE,CAAC;QACpB,KAAK,IAAI;YACP,OAAO,gBAAgB,CAAC;QAC1B,KAAK,WAAW;YACd,OAAO,uBAAuB,CAAC;QACjC,KAAK,UAAU;YACb,OAAO,sBAAsB,CAAC;QAChC;YACE,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/utils/monaco-decorators.d.ts

@@ -0,0 +1,17 @@
+import type { editor } from 'monaco-editor';
+/**
+ * Apply decorations to highlight walkerOS data attributes in Monaco editor
+ *
+ * This function scans the editor content for data-elb* attributes and
+ * applies color highlighting to match the website's Prism.js styling.
+ *
+ * @param editor - Monaco editor instance
+ * @param monaco - Monaco module
+ */
+export declare function applyDataElbDecorations(monacoEditor: editor.IStandaloneCodeEditor, monaco: typeof import('monaco-editor')): () => void;
+/**
+ * Register CSS styles for data-elb attribute decorations
+ * Call this once during app initialization
+ */
+export declare function registerDataElbStyles(): void;
+//# sourceMappingURL=monaco-decorators.d.ts.map

package/dist/utils/monaco-decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-decorators.d.ts","sourceRoot":"","sources":["../../src/utils/monaco-decorators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAe5C;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,CAAC,qBAAqB,EAC1C,MAAM,EAAE,cAAc,eAAe,CAAC,GACrC,MAAM,IAAI,CAsDZ;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,SAcpC"}