@walkeros/explorer 0.5.0 → 1.0.0

package/dist/utils/monaco-formatters.js

@@ -0,0 +1,139 @@
+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';
+/**
+ * Register Monaco Editor formatting providers for various languages
+ *
+ * Uses Prettier for professional-grade code formatting.
+ * Registered once when Monaco is initialized.
+ *
+ * Supported languages:
+ * - JavaScript (parser: babel)
+ * - TypeScript (parser: typescript)
+ * - JSON (native JSON.stringify)
+ * - HTML (parser: html)
+ * - CSS (parser: css)
+ */
+export function registerFormatters(monacoInstance) {
+    // JavaScript formatter
+    monacoInstance.languages.registerDocumentFormattingEditProvider('javascript', {
+        async provideDocumentFormattingEdits(model, options) {
+            try {
+                const text = model.getValue();
+                const formatted = await prettier.format(text, {
+                    parser: 'babel',
+                    plugins: [prettierBabel, prettierEstree],
+                    tabWidth: options.tabSize,
+                    useTabs: !options.insertSpaces,
+                    semi: true,
+                    singleQuote: true,
+                    trailingComma: 'all',
+                });
+                return [
+                    {
+                        range: model.getFullModelRange(),
+                        text: formatted,
+                    },
+                ];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+    });
+    // TypeScript formatter
+    monacoInstance.languages.registerDocumentFormattingEditProvider('typescript', {
+        async provideDocumentFormattingEdits(model, options) {
+            try {
+                const text = model.getValue();
+                const formatted = await prettier.format(text, {
+                    parser: 'typescript',
+                    plugins: [prettierTypescript, prettierEstree],
+                    tabWidth: options.tabSize,
+                    useTabs: !options.insertSpaces,
+                    semi: true,
+                    singleQuote: true,
+                    trailingComma: 'all',
+                });
+                return [
+                    {
+                        range: model.getFullModelRange(),
+                        text: formatted,
+                    },
+                ];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+    });
+    // JSON formatter (use native JSON.stringify for simplicity)
+    monacoInstance.languages.registerDocumentFormattingEditProvider('json', {
+        async provideDocumentFormattingEdits(model, options) {
+            try {
+                const text = model.getValue();
+                const parsed = JSON.parse(text);
+                const formatted = JSON.stringify(parsed, null, options.tabSize);
+                return [
+                    {
+                        range: model.getFullModelRange(),
+                        text: formatted,
+                    },
+                ];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+    });
+    // HTML formatter
+    monacoInstance.languages.registerDocumentFormattingEditProvider('html', {
+        async provideDocumentFormattingEdits(model, options) {
+            try {
+                const text = model.getValue();
+                const formatted = await prettier.format(text, {
+                    parser: 'html',
+                    plugins: [prettierHtml],
+                    tabWidth: options.tabSize,
+                    useTabs: !options.insertSpaces,
+                    htmlWhitespaceSensitivity: 'css',
+                });
+                return [
+                    {
+                        range: model.getFullModelRange(),
+                        text: formatted,
+                    },
+                ];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+    });
+    // CSS formatter
+    monacoInstance.languages.registerDocumentFormattingEditProvider('css', {
+        async provideDocumentFormattingEdits(model, options) {
+            try {
+                const text = model.getValue();
+                const formatted = await prettier.format(text, {
+                    parser: 'css',
+                    plugins: [prettierHtml], // CSS parser is in html plugin
+                    tabWidth: options.tabSize,
+                    useTabs: !options.insertSpaces,
+                });
+                return [
+                    {
+                        range: model.getFullModelRange(),
+                        text: formatted,
+                    },
+                ];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+    });
+}
+//# sourceMappingURL=monaco-formatters.js.map

package/dist/utils/monaco-formatters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-formatters.js","sourceRoot":"","sources":["../../src/utils/monaco-formatters.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,174 @@
+/**
+ * Monaco Editor TypeScript Type Management
+ *
+ * This utility manages TypeScript type definitions in Monaco Editor for:
+ * 1. Static walkerOS core types (bundled at build time via Vite ?raw import)
+ * 2. Dynamic destination types (loaded on-the-fly when destinations are added)
+ * 3. Context-specific function signatures (condition, fn, validate)
+ *
+ * Architecture:
+ * - Uses monaco.languages.typescript.typescriptDefaults.addExtraLib()
+ * - Each type definition gets a unique file path (e.g., 'file:///destinations/gtag.d.ts')
+ * - Types can be added/removed dynamically without page reload
+ * - Core types are bundled for offline support and predictable versioning
+ */
+import type { Monaco } from '@monaco-editor/react';
+/**
+ * Configuration for TypeScript compiler options
+ */
+export declare function configureMonacoTypeScript(monaco: Monaco): void;
+/**
+ * Add a type library from a string
+ *
+ * @param monaco - Monaco instance
+ * @param uri - Unique identifier (e.g., 'file:///destinations/gtag.d.ts')
+ * @param content - TypeScript definition content
+ * @returns True if added, false if already exists
+ */
+export declare function addTypeLibrary(monaco: Monaco, uri: string, content: string): boolean;
+/**
+ * Remove a type library
+ *
+ * @param uri - URI to remove
+ * @returns True if removed, false if not found
+ */
+export declare function removeTypeLibrary(uri: string): boolean;
+/**
+ * Update a type library (remove + add)
+ *
+ * @param monaco - Monaco instance
+ * @param uri - URI to update
+ * @param content - New content
+ */
+export declare function updateTypeLibrary(monaco: Monaco, uri: string, content: string): void;
+/**
+ * Load type definitions from a URL
+ *
+ * @param monaco - Monaco instance
+ * @param url - URL to .d.ts file
+ * @param uri - Optional custom URI (defaults to URL)
+ */
+export declare function loadTypeLibraryFromURL(monaco: Monaco, url: string, uri?: string): Promise<boolean>;
+/**
+ * Options for loading package types dynamically
+ */
+export interface LoadPackageTypesOptions {
+    /** Package name (e.g., '@walkeros/destination-gtag') */
+    package: string;
+    /** Version to load (e.g., '0.1.0', 'latest') */
+    version?: string;
+    /** CDN to use ('unpkg' or 'jsdelivr') */
+    cdn?: 'unpkg' | 'jsdelivr';
+    /** Path to .d.ts file within package (defaults to '/dist/index.d.ts') */
+    typesPath?: string;
+}
+export interface LoadPackageTypesOptions {
+    package: string;
+    version?: string;
+}
+export declare function loadPackageTypes(monaco: Monaco, options: LoadPackageTypesOptions): Promise<boolean>;
+/**
+ * Load walkerOS core types (bundled at build time)
+ *
+ * Uses bundled types imported via Vite's ?raw import.
+ * This ensures types are always available offline and match the installed version.
+ */
+export declare function loadWalkerOSCoreTypes(monaco: Monaco): boolean;
+/**
+ * Type of function context (fn, condition, validate)
+ */
+export type FunctionType = 'condition' | 'fn' | 'validate';
+/**
+ * Add context-specific globals for function editors
+ *
+ * Provides type definitions for inline function parameters without imports.
+ * Supports three function types:
+ * - fn: Transform functions (value, mapping, options) => Property
+ * - condition: Condition functions (value, mapping, collector) => boolean
+ * - validate: Validation functions (value) => boolean
+ */
+export interface FunctionContext {
+    type: FunctionType;
+    valueType?: string;
+}
+export declare function addFunctionContextTypes(monaco: Monaco, context: FunctionContext): void;
+/**
+ * Add destination-specific types dynamically
+ *
+ * @param monaco - Monaco instance
+ * @param destinationId - Unique destination identifier (e.g., 'gtag', 'fbq')
+ * @param typeDefinition - TypeScript definition for destination's custom config/event
+ *
+ * @example
+ * ```typescript
+ * addDestinationType(monaco, 'gtag', `
+ *   declare namespace Gtag {
+ *     interface Settings {
+ *       measurementId: string;
+ *       sendPageView?: boolean;
+ *     }
+ *
+ *     interface EventParams {
+ *       event_category?: string;
+ *       event_label?: string;
+ *       value?: number;
+ *     }
+ *   }
+ *
+ *   // Extend WalkerOS namespace
+ *   declare namespace WalkerOS {
+ *     namespace Destination {
+ *       interface ConfigMap {
+ *         gtag: Gtag.Settings;
+ *       }
+ *     }
+ *   }
+ * `);
+ * ```
+ */
+export declare function addDestinationType(monaco: Monaco, destinationId: string, typeDefinition: string): void;
+/**
+ * Remove destination types when destination is removed
+ */
+export declare function removeDestinationType(destinationId: string): void;
+/**
+ * Simple helper to register only walkerOS core types
+ *
+ * Use this for basic scenarios where you just need @walkeros/core types.
+ * For advanced usage (destinations, function contexts), use initializeMonacoTypes.
+ *
+ * @param monaco - Monaco editor instance
+ *
+ * @example
+ * ```typescript
+ * const handleBeforeMount = (monaco: Monaco) => {
+ *   registerWalkerOSTypes(monaco);
+ * };
+ * ```
+ */
+export declare function registerWalkerOSTypes(monaco: Monaco): void;
+/**
+ * Initialize Monaco with walkerOS types (full setup)
+ *
+ * Call this once in CodeBox's beforeMount handler.
+ * Includes core types, TypeScript config, and default function context.
+ *
+ * @param monaco - Monaco editor instance
+ *
+ * @example
+ * ```typescript
+ * const handleBeforeMount = (monaco: Monaco) => {
+ *   initializeMonacoTypes(monaco);
+ * };
+ * ```
+ */
+export declare function initializeMonacoTypes(monaco: Monaco): void;
+/**
+ * Get all loaded type libraries (for debugging)
+ */
+export declare function getLoadedTypeLibraries(): string[];
+/**
+ * Clear all type libraries (for testing)
+ */
+export declare function clearAllTypeLibraries(): void;
+//# sourceMappingURL=monaco-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-types.d.ts","sourceRoot":"","sources":["../../src/utils/monaco-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAoBnD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,QAkCvD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,OAAO,CA2BT;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAatD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAclB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,GAAG,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAC3B,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAiDD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,OAAO,CAAC,CA0BlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB7D;AAyDD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,IAAI,GAAG,UAAU,CAAC;AAE3D;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,QASzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,QAIvB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,QAG1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAS1D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,SAKpC"}

package/dist/utils/monaco-types.js

@@ -0,0 +1,378 @@
+/**
+ * Monaco Editor TypeScript Type Management
+ *
+ * This utility manages TypeScript type definitions in Monaco Editor for:
+ * 1. Static walkerOS core types (bundled at build time via Vite ?raw import)
+ * 2. Dynamic destination types (loaded on-the-fly when destinations are added)
+ * 3. Context-specific function signatures (condition, fn, validate)
+ *
+ * Architecture:
+ * - Uses monaco.languages.typescript.typescriptDefaults.addExtraLib()
+ * - Each type definition gets a unique file path (e.g., 'file:///destinations/gtag.d.ts')
+ * - Types can be added/removed dynamically without page reload
+ * - Core types are bundled for offline support and predictable versioning
+ */
+import { getContextTypes } from './monaco-context-types';
+// This import will be replaced by tsup plugin with actual TypeScript content
+import walkerosCoreTypesBundled from 'virtual:walkeros-core-types';
+/**
+ * Registry of loaded type libraries
+ */
+const typeLibraries = new Map();
+/**
+ * Configuration for TypeScript compiler options
+ */
+export function configureMonacoTypeScript(monaco) {
+    monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+        target: monaco.languages.typescript.ScriptTarget.ES2020,
+        lib: ['es2020'],
+        allowNonTsExtensions: true,
+        moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+        module: monaco.languages.typescript.ModuleKind.CommonJS,
+        noEmit: true,
+        esModuleInterop: true,
+        jsx: monaco.languages.typescript.JsxEmit.React,
+        allowJs: true,
+        checkJs: false,
+        strict: false,
+        noImplicitAny: false,
+        strictNullChecks: false,
+    });
+    monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+        noSemanticValidation: false,
+        noSyntaxValidation: false,
+        diagnosticCodesToIgnore: [1108, 1005],
+    });
+    monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+        target: monaco.languages.typescript.ScriptTarget.ES2020,
+        lib: ['es2020'],
+        allowNonTsExtensions: true,
+        moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+        module: monaco.languages.typescript.ModuleKind.CommonJS,
+        noEmit: true,
+        esModuleInterop: true,
+        jsx: monaco.languages.typescript.JsxEmit.React,
+        strict: false,
+    });
+}
+/**
+ * Add a type library from a string
+ *
+ * @param monaco - Monaco instance
+ * @param uri - Unique identifier (e.g., 'file:///destinations/gtag.d.ts')
+ * @param content - TypeScript definition content
+ * @returns True if added, false if already exists
+ */
+export function addTypeLibrary(monaco, uri, content) {
+    // Check if already loaded
+    if (typeLibraries.has(uri)) {
+        return false;
+    }
+    // Add to both JavaScript and TypeScript language services
+    // This ensures types work whether the editor is in JS or TS mode
+    const jsDisposable = monaco.languages.typescript.javascriptDefaults.addExtraLib(content, uri);
+    const tsDisposable = monaco.languages.typescript.typescriptDefaults.addExtraLib(content, uri);
+    // Track in registry (store both disposables)
+    typeLibraries.set(uri, {
+        uri,
+        content,
+        disposable: {
+            dispose: () => {
+                jsDisposable.dispose();
+                tsDisposable.dispose();
+            },
+        },
+    });
+    return true;
+}
+/**
+ * Remove a type library
+ *
+ * @param uri - URI to remove
+ * @returns True if removed, false if not found
+ */
+export function removeTypeLibrary(uri) {
+    const lib = typeLibraries.get(uri);
+    if (!lib) {
+        return false;
+    }
+    // Dispose Monaco resource
+    lib.disposable?.dispose();
+    // Remove from registry
+    typeLibraries.delete(uri);
+    return true;
+}
+/**
+ * Update a type library (remove + add)
+ *
+ * @param monaco - Monaco instance
+ * @param uri - URI to update
+ * @param content - New content
+ */
+export function updateTypeLibrary(monaco, uri, content) {
+    removeTypeLibrary(uri);
+    addTypeLibrary(monaco, uri, content);
+}
+/**
+ * Load type definitions from a URL
+ *
+ * @param monaco - Monaco instance
+ * @param url - URL to .d.ts file
+ * @param uri - Optional custom URI (defaults to URL)
+ */
+export async function loadTypeLibraryFromURL(monaco, url, uri) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return false;
+        }
+        const content = await response.text();
+        const typeUri = uri || `file:///${url}`;
+        return addTypeLibrary(monaco, typeUri, content);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Strip problematic imports from type definition content
+ *
+ * Removes import statements that Monaco can't resolve, while preserving:
+ * - Type declarations
+ * - Export statements
+ * - Re-export statements (export * from / export { } from)
+ *
+ * Uses multiple strategies for robustness:
+ * 1. Simple single-line imports (fast path)
+ * 2. Multi-line imports (comprehensive)
+ * 3. Import type assertions
+ *
+ * Does NOT remove:
+ * - export { } from 'module' (re-exports)
+ * - export * from 'module' (re-exports)
+ * - Triple-slash directives (/// <reference types="..." />)
+ *
+ * @param content - Raw .d.ts file content
+ * @returns Cleaned content safe for Monaco
+ */
+function stripExternalImports(content) {
+    // Strategy 1: Remove simple single-line imports
+    // Matches: import ... from '...';
+    // Handles: import type, import *, import { }, default imports
+    let cleaned = content.replace(/^import\s+(?:type\s+)?(?:\*\s+as\s+\w+|\{[^}]*\}|[\w$]+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+))?\s+from\s+['"][^'"]+['"];?\s*$/gm, '');
+    // Strategy 2: Remove multi-line imports (more aggressive)
+    // Matches imports that span multiple lines
+    cleaned = cleaned.replace(/^import\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|[\w$]+)\s+from\s+['"][^'"]+['"];?\s*$/gms, '');
+    // Strategy 3: Remove import type assertions
+    // Matches: import('module')
+    cleaned = cleaned.replace(/import\s*\(\s*['"][^'"]+['"]\s*\)/g, 'any');
+    // Clean up excessive blank lines (more than 2 consecutive)
+    cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+    return cleaned;
+}
+export async function loadPackageTypes(monaco, options) {
+    const { package: packageName, version = 'latest' } = options;
+    const uri = `file:///node_modules/${packageName}/index.d.ts`;
+    if (typeLibraries.has(uri)) {
+        return true;
+    }
+    const url = `https://cdn.jsdelivr.net/npm/${packageName}@${version}/dist/index.d.ts`;
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return false;
+        }
+        let content = await response.text();
+        content = stripExternalImports(content);
+        const moduleContent = `declare module '${packageName}' {\n${content}\n}`;
+        const success = addTypeLibrary(monaco, uri, moduleContent);
+        return success;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load walkerOS core types (bundled at build time)
+ *
+ * Uses bundled types imported via Vite's ?raw import.
+ * This ensures types are always available offline and match the installed version.
+ */
+export function loadWalkerOSCoreTypes(monaco) {
+    const uri = 'file:///node_modules/@walkeros/core/index.d.ts';
+    // Check if already loaded
+    if (typeLibraries.has(uri)) {
+        return true;
+    }
+    // Clean the types using the same robust stripping function
+    const cleanedTypes = stripExternalImports(walkerosCoreTypesBundled);
+    // Wrap in module declaration
+    const moduleContent = `declare module '@walkeros/core' {
+${cleanedTypes}
+}`;
+    return addTypeLibrary(monaco, uri, moduleContent);
+}
+/**
+ * Minimal fallback types if we can't load from node_modules
+ */
+function getMinimalWalkerOSTypes() {
+    return `
+declare namespace WalkerOS {
+  export interface Event {
+    entity: string;
+    action: string;
+    data?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    user?: {
+      id?: string;
+      device?: string;
+      session?: string;
+      [key: string]: unknown;
+    };
+    nested?: unknown[];
+    consent?: Record<string, boolean>;
+    id?: string;
+    trigger?: string;
+    timestamp?: number;
+    timing?: number;
+    count?: number;
+    version?: {
+      client?: string;
+      tagging?: number;
+    };
+  }
+
+  export interface Properties {
+    [key: string]: unknown;
+  }
+
+  export interface Mapping {
+    [key: string]: unknown;
+  }
+
+  export interface Collector {
+    push: (event: Partial<Event>) => Promise<unknown>;
+    [key: string]: unknown;
+  }
+
+  export namespace Destination {
+    export interface Config<T = unknown> {
+      id?: string;
+      mapping?: Mapping;
+      custom?: T;
+      [key: string]: unknown;
+    }
+  }
+}
+`;
+}
+export function addFunctionContextTypes(monaco, context) {
+    const uri = `file:///context/${context.type}.d.ts`;
+    // Use hand-crafted type templates from monaco-context-types
+    const contextTypes = getContextTypes(context.type);
+    // Update or add
+    updateTypeLibrary(monaco, uri, contextTypes);
+}
+/**
+ * Add destination-specific types dynamically
+ *
+ * @param monaco - Monaco instance
+ * @param destinationId - Unique destination identifier (e.g., 'gtag', 'fbq')
+ * @param typeDefinition - TypeScript definition for destination's custom config/event
+ *
+ * @example
+ * ```typescript
+ * addDestinationType(monaco, 'gtag', `
+ *   declare namespace Gtag {
+ *     interface Settings {
+ *       measurementId: string;
+ *       sendPageView?: boolean;
+ *     }
+ *
+ *     interface EventParams {
+ *       event_category?: string;
+ *       event_label?: string;
+ *       value?: number;
+ *     }
+ *   }
+ *
+ *   // Extend WalkerOS namespace
+ *   declare namespace WalkerOS {
+ *     namespace Destination {
+ *       interface ConfigMap {
+ *         gtag: Gtag.Settings;
+ *       }
+ *     }
+ *   }
+ * `);
+ * ```
+ */
+export function addDestinationType(monaco, destinationId, typeDefinition) {
+    const uri = `file:///destinations/${destinationId}.d.ts`;
+    updateTypeLibrary(monaco, uri, typeDefinition);
+}
+/**
+ * Remove destination types when destination is removed
+ */
+export function removeDestinationType(destinationId) {
+    const uri = `file:///destinations/${destinationId}.d.ts`;
+    removeTypeLibrary(uri);
+}
+/**
+ * Simple helper to register only walkerOS core types
+ *
+ * Use this for basic scenarios where you just need @walkeros/core types.
+ * For advanced usage (destinations, function contexts), use initializeMonacoTypes.
+ *
+ * @param monaco - Monaco editor instance
+ *
+ * @example
+ * ```typescript
+ * const handleBeforeMount = (monaco: Monaco) => {
+ *   registerWalkerOSTypes(monaco);
+ * };
+ * ```
+ */
+export function registerWalkerOSTypes(monaco) {
+    configureMonacoTypeScript(monaco);
+    loadWalkerOSCoreTypes(monaco);
+}
+/**
+ * Initialize Monaco with walkerOS types (full setup)
+ *
+ * Call this once in CodeBox's beforeMount handler.
+ * Includes core types, TypeScript config, and default function context.
+ *
+ * @param monaco - Monaco editor instance
+ *
+ * @example
+ * ```typescript
+ * const handleBeforeMount = (monaco: Monaco) => {
+ *   initializeMonacoTypes(monaco);
+ * };
+ * ```
+ */
+export function initializeMonacoTypes(monaco) {
+    // Configure compiler
+    configureMonacoTypeScript(monaco);
+    // Load core types (now synchronous with bundled types)
+    loadWalkerOSCoreTypes(monaco);
+    // Add default function context (condition)
+    addFunctionContextTypes(monaco, { type: 'condition' });
+}
+/**
+ * Get all loaded type libraries (for debugging)
+ */
+export function getLoadedTypeLibraries() {
+    return Array.from(typeLibraries.keys());
+}
+/**
+ * Clear all type libraries (for testing)
+ */
+export function clearAllTypeLibraries() {
+    for (const [uri, lib] of typeLibraries.entries()) {
+        lib.disposable?.dispose();
+    }
+    typeLibraries.clear();
+}
+//# sourceMappingURL=monaco-types.js.map