@walkeros/explorer 2.1.4 → 2.1.5

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

@@ -1,426 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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,CAAC,WAA4C;IAC1E,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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/utils/monaco-decorators.js

@@ -1,81 +0,0 @@
-/**
- * Regular expressions to match walkerOS data attributes
- */
-const DATA_ELB_PATTERNS = [
-    /\bdata-elb(?!-)\b/g, // data-elb (not followed by hyphen)
-    /\bdata-elbaction\b/g, // data-elbaction
-    /\bdata-elbactions\b/g, // data-elbactions
-    /\bdata-elbglobals\b/g, // data-elbglobals
-    /\bdata-elbcontext\b/g, // data-elbcontext
-    /\bdata-elblink\b/g, // data-elblink
-    /\bdata-elb-[\w-]+\b/g, // data-elb-* (property attributes)
-];
-/**
- * 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 function applyDataElbDecorations(monacoEditor, monaco) {
-    const decorationIds = [];
-    const updateDecorations = () => {
-        const model = monacoEditor.getModel();
-        if (!model)
-            return;
-        const content = model.getValue();
-        const decorations = [];
-        // Find all matches for each pattern
-        DATA_ELB_PATTERNS.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(content)) !== null) {
-                const startPos = model.getPositionAt(match.index);
-                const endPos = model.getPositionAt(match.index + match[0].length);
-                decorations.push({
-                    range: new monaco.Range(startPos.lineNumber, startPos.column, endPos.lineNumber, endPos.column),
-                    options: {
-                        inlineClassName: 'elb-data-attribute',
-                        inlineClassNameAffectsLetterSpacing: true,
-                    },
-                });
-            }
-        });
-        // Apply decorations
-        const newDecorationIds = monacoEditor.deltaDecorations(decorationIds, decorations);
-        decorationIds.length = 0;
-        decorationIds.push(...newDecorationIds);
-    };
-    // Initial decoration
-    updateDecorations();
-    // Update decorations on content change
-    const disposable = monacoEditor.onDidChangeModelContent(() => {
-        updateDecorations();
-    });
-    // Return cleanup function
-    return () => {
-        disposable.dispose();
-        monacoEditor.deltaDecorations(decorationIds, []);
-    };
-}
-/**
- * Register CSS styles for data-elb attribute decorations
- * Call this once during app initialization
- */
-export function registerDataElbStyles() {
-    if (typeof document === 'undefined')
-        return;
-    const styleId = 'elb-monaco-data-attribute-styles';
-    if (document.getElementById(styleId))
-        return;
-    const style = document.createElement('style');
-    style.id = styleId;
-    style.textContent = `
-    .monaco-editor .elb-data-attribute {
-      color: var(--color-highlight-primary, #01b5e2) !important;
-    }
-  `;
-    document.head.appendChild(style);
-}
-//# sourceMappingURL=monaco-decorators.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"monaco-decorators.js","sourceRoot":"","sources":["../../src/utils/monaco-decorators.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,iBAAiB,GAAG;IACxB,oBAAoB,EAAE,oCAAoC;IAC1D,qBAAqB,EAAE,iBAAiB;IACxC,sBAAsB,EAAE,kBAAkB;IAC1C,sBAAsB,EAAE,kBAAkB;IAC1C,sBAAsB,EAAE,kBAAkB;IAC1C,mBAAmB,EAAE,eAAe;IACpC,sBAAsB,EAAE,mCAAmC;CAC5D,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CACrC,YAA0C,EAC1C,MAAsC;IAEtC,MAAM,aAAa,GAAa,EAAE,CAAC;IAEnC,MAAM,iBAAiB,GAAG,GAAG,EAAE;QAC7B,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC;QACtC,IAAI,CAAC,KAAK;YAAE,OAAO;QAEnB,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,WAAW,GAAmC,EAAE,CAAC;QAEvD,oCAAoC;QACpC,iBAAiB,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACpC,IAAI,KAA6B,CAAC;YAClC,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBAChD,MAAM,QAAQ,GAAG,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAClD,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBAElE,WAAW,CAAC,IAAI,CAAC;oBACf,KAAK,EAAE,IAAI,MAAM,CAAC,KAAK,CACrB,QAAQ,CAAC,UAAU,EACnB,QAAQ,CAAC,MAAM,EACf,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,MAAM,CACd;oBACD,OAAO,EAAE;wBACP,eAAe,EAAE,oBAAoB;wBACrC,mCAAmC,EAAE,IAAI;qBAC1C;iBACF,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,oBAAoB;QACpB,MAAM,gBAAgB,GAAG,YAAY,CAAC,gBAAgB,CACpD,aAAa,EACb,WAAW,CACZ,CAAC;QACF,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,aAAa,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEF,qBAAqB;IACrB,iBAAiB,EAAE,CAAC;IAEpB,uCAAuC;IACvC,MAAM,UAAU,GAAG,YAAY,CAAC,uBAAuB,CAAC,GAAG,EAAE;QAC3D,iBAAiB,EAAE,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,0BAA0B;IAC1B,OAAO,GAAG,EAAE;QACV,UAAU,CAAC,OAAO,EAAE,CAAC;QACrB,YAAY,CAAC,gBAAgB,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;IACnD,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,IAAI,OAAO,QAAQ,KAAK,WAAW;QAAE,OAAO;IAE5C,MAAM,OAAO,GAAG,kCAAkC,CAAC;IACnD,IAAI,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC;QAAE,OAAO;IAE7C,MAAM,KAAK,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IAC9C,KAAK,CAAC,EAAE,GAAG,OAAO,CAAC;IACnB,KAAK,CAAC,WAAW,GAAG;;;;GAInB,CAAC;IACF,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC"}

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

@@ -1,16 +0,0 @@
-import type * as monaco from 'monaco-editor';
-/**
- * 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 declare function registerFormatters(monacoInstance: typeof monaco): void;
-//# sourceMappingURL=monaco-formatters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"monaco-formatters.d.ts","sourceRoot":"","sources":["../../src/utils/monaco-formatters.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,OAAO,MAAM,GAAG,IAAI,CA4HtE"}

package/dist/utils/monaco-formatters.js

@@ -1,139 +0,0 @@
-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