@walkeros/explorer 0.3.1 → 1.0.0

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,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

@@ -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;AAa5C;;;;;;;;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

@@ -0,0 +1,79 @@
+/**
+ * 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-elbglobals\b/g, // data-elbglobals
+    /\bdata-elbcontext\b/g, // data-elbcontext
+    /\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

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

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

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

@@ -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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"}