@nuraly/lumenui 0.1.0

package/dist/src/components/code-editor/code-editor.component.js

@@ -0,0 +1,532 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LitElement, html } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { createRef, ref } from 'lit/directives/ref.js';
+import { styles } from './code-editor.style.js';
+import { CODE_EDITOR_THEME } from './code-editor.types.js';
+import { ThemeAwareMixin } from '../../shared/theme-mixin.js';
+// Monaco Editor Imports
+import * as monaco from 'monaco-editor';
+import { registerCompletion } from 'monacopilot';
+// @ts-ignore
+import monacoStyles from 'monaco-editor/min/vs/editor/editor.main.css?inline';
+// @ts-ignore
+import editorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+// @ts-ignore
+import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
+// @ts-ignore
+import htmlWorker from 'monaco-editor/esm/vs/language/html/html.worker?worker';
+// @ts-ignore
+import jsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker';
+// Setup Monaco workers (client-side only)
+if (typeof self !== 'undefined') {
+    self.MonacoEnvironment = {
+        getWorker(_, label) {
+            if (label === 'typescript' || label === 'javascript') {
+                return new tsWorker();
+            }
+            if (label === 'json') {
+                return new jsonWorker();
+            }
+            if (label === 'html') {
+                return new htmlWorker();
+            }
+            return new editorWorker();
+        },
+    };
+}
+/**
+ * NuralyUI Code Editor component wrapping Monaco Editor.
+ *
+ * @example
+ * ```html
+ * <nr-code-editor
+ *   language="javascript"
+ *   theme="vs-dark"
+ *   .code=${"console.log('Hello');"}
+ *   @nr-change=${(e) => console.log(e.detail.value)}
+ * ></nr-code-editor>
+ * ```
+ *
+ * @fires nr-change - Fired when the code content changes
+ * @fires nr-keydown - Fired on keydown events in the editor
+ * @fires nr-keyup - Fired on keyup events in the editor
+ * @fires nr-focus - Fired when the editor gains focus
+ * @fires nr-blur - Fired when the editor loses focus
+ * @fires nr-ready - Fired when the editor is ready
+ *
+ * @csspart editor-container - The container wrapping the editor
+ *
+ * @cssprop [--nr-code-editor-width=100%] - Width of the editor
+ * @cssprop [--nr-code-editor-height=100%] - Height of the editor
+ * @cssprop [--nr-code-editor-min-height=0] - Minimum height
+ * @cssprop [--nr-code-editor-max-height=none] - Maximum height
+ * @cssprop [--nr-code-editor-border-radius=4px] - Border radius
+ */
+let NrCodeEditorElement = class NrCodeEditorElement extends ThemeAwareMixin(LitElement) {
+    constructor() {
+        super(...arguments);
+        /** Whether editor is initialized */
+        this.isEditorReady = false;
+        /** Reference to the editor container */
+        this.containerRef = createRef();
+        /** Makes the editor read-only */
+        this.readonly = false;
+        /** Editor theme (vs, vs-dark, hc-black, hc-light) */
+        this.theme = CODE_EDITOR_THEME.Dark;
+        /** Programming language for syntax highlighting */
+        this.language = 'javascript';
+        /** The code content */
+        this.code = '';
+        /** Show line numbers */
+        this.lineNumbers = true;
+        /** Show minimap */
+        this.minimap = false;
+        /** Enable word wrap */
+        this.wordWrap = false;
+        /** Font size in pixels */
+        this.fontSize = 13;
+        /** Enable AI completions via monacopilot */
+        this.aiCompletions = true;
+        /** API endpoint for AI completions */
+        this.completionsEndpoint = '/api/v1/copilot/completion';
+        /** Extra type definitions for Monaco IntelliSense (host-provided) */
+        this.extraTypeDefinitions = '';
+    }
+    render() {
+        return html `
+      <style>
+        ${monacoStyles}
+      </style>
+      <div class="editor-container" part="editor-container">
+        <main ${ref(this.containerRef)}></main>
+      </div>
+    `;
+    }
+    /**
+     * Returns the current code contents
+     */
+    getValue() {
+        var _a, _b;
+        return (_b = (_a = this.editor) === null || _a === void 0 ? void 0 : _a.getValue()) !== null && _b !== void 0 ? _b : '';
+    }
+    /**
+     * Sets the editor value programmatically
+     */
+    setValue(value) {
+        if (this.editor) {
+            const cursorPosition = this.editor.getPosition();
+            this.editor.setValue(value);
+            if (cursorPosition) {
+                this.editor.setPosition(cursorPosition);
+            }
+        }
+    }
+    /**
+     * Updates Monaco editor options
+     */
+    setOptions(options) {
+        var _a;
+        (_a = this.editor) === null || _a === void 0 ? void 0 : _a.updateOptions(options);
+    }
+    /**
+     * Focus the editor
+     */
+    focus() {
+        var _a;
+        (_a = this.editor) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    firstUpdated() {
+        if (!this.containerRef.value) {
+            console.error('NrCodeEditor: Container element not available');
+            return;
+        }
+        this.initializeEditor();
+    }
+    initializeEditor() {
+        // Determine initial theme - prefer data-theme if no explicit theme set
+        const initialTheme = this.getInitialTheme();
+        try {
+            this.editor = monaco.editor.create(this.containerRef.value, {
+                value: this.code,
+                language: this.language,
+                theme: initialTheme,
+                fontSize: this.fontSize,
+                automaticLayout: true,
+                readOnly: this.readonly,
+                lineNumbers: this.lineNumbers ? 'on' : 'off',
+                minimap: { enabled: this.minimap },
+                wordWrap: this.wordWrap ? 'on' : 'off',
+            });
+            this.isEditorReady = true;
+        }
+        catch (error) {
+            console.error('NrCodeEditor: Failed to create editor', error);
+            return;
+        }
+        this.setupCustomIntelliSense();
+        if (this.aiCompletions) {
+            registerCompletion(monaco, this.editor, {
+                language: this.language,
+                endpoint: this.completionsEndpoint,
+            });
+        }
+        this.setupEventListeners();
+        this.setupThemeListener();
+        this.dispatchEvent(new CustomEvent('nr-ready', {
+            detail: { editor: this.editor },
+            bubbles: true,
+            composed: true,
+        }));
+    }
+    setupEventListeners() {
+        var _a;
+        if (!this.editor)
+            return;
+        // Content change events
+        (_a = this.editor.getModel()) === null || _a === void 0 ? void 0 : _a.onDidChangeContent(() => {
+            this.emit('nr-change', { value: this.getValue() });
+        });
+        // Keyboard events
+        this.editor.onKeyDown((e) => {
+            this.emit('nr-keydown', this.createKeyEventDetail(e));
+        });
+        this.editor.onKeyUp((e) => {
+            this.emit('nr-keyup', this.createKeyEventDetail(e));
+        });
+        // Focus events
+        this.editor.onDidFocusEditorWidget(() => this.emit('nr-focus'));
+        this.editor.onDidBlurEditorWidget(() => this.emit('nr-blur'));
+    }
+    /** Helper to create keyboard event detail */
+    createKeyEventDetail(e) {
+        return {
+            event: e.browserEvent,
+            key: e.browserEvent.key,
+            code: e.browserEvent.code,
+            ctrlKey: e.browserEvent.ctrlKey,
+            shiftKey: e.browserEvent.shiftKey,
+            altKey: e.browserEvent.altKey,
+            metaKey: e.browserEvent.metaKey,
+        };
+    }
+    /** Helper to emit custom events */
+    emit(eventName, detail) {
+        this.dispatchEvent(new CustomEvent(eventName, {
+            detail,
+            bubbles: true,
+            composed: true,
+        }));
+    }
+    setupThemeListener() {
+        // The ThemeAwareMixin handles theme observation automatically
+        // We just need to apply the initial theme
+        this.applyThemeFromMixin();
+    }
+    /**
+     * Convert the mixin's currentTheme to Monaco theme
+     * Uses explicit theme prop if set, otherwise derives from data-theme
+     */
+    getMonacoThemeFromMixin() {
+        // If explicit theme prop is set, use it
+        if (this.theme) {
+            return this.theme;
+        }
+        // Use the mixin's currentTheme which handles data-theme and system preference
+        const currentTheme = this.currentTheme;
+        // Map theme values to Monaco themes
+        if (currentTheme.includes('dark')) {
+            return CODE_EDITOR_THEME.Dark;
+        }
+        return CODE_EDITOR_THEME.Light;
+    }
+    /**
+     * Apply the current theme from the mixin to Monaco editor
+     */
+    applyThemeFromMixin() {
+        if (!this.isEditorReady || !this.editor)
+            return;
+        const monacoTheme = this.getMonacoThemeFromMixin();
+        // Only update if theme has changed
+        if (monacoTheme !== this.lastAppliedTheme) {
+            try {
+                monaco.editor.setTheme(monacoTheme);
+                this.lastAppliedTheme = monacoTheme;
+            }
+            catch (_a) {
+                // Ignore errors
+            }
+        }
+    }
+    /**
+     * Get the initial theme for the editor
+     * Priority: explicit theme prop > data-theme > system preference
+     */
+    getInitialTheme() {
+        return this.getMonacoThemeFromMixin();
+    }
+    setupCustomIntelliSense() {
+        const tsDefaults = monaco.languages.typescript.typescriptDefaults;
+        const jsDefaults = monaco.languages.typescript.javascriptDefaults;
+        // Add custom type definitions for both TypeScript and JavaScript
+        [tsDefaults, jsDefaults].forEach(defaults => {
+            if (this.extraTypeDefinitions) {
+                defaults.addExtraLib(this.extraTypeDefinitions, 'database-types.d.ts');
+            }
+        });
+        // Base compiler options shared between TS and JS
+        const baseCompilerOptions = {
+            target: monaco.languages.typescript.ScriptTarget.ES2020,
+            allowNonTsExtensions: true,
+            moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+            module: monaco.languages.typescript.ModuleKind.CommonJS,
+            noEmit: true,
+            esModuleInterop: true,
+            allowJs: true,
+        };
+        // TypeScript-specific options
+        tsDefaults.setCompilerOptions(Object.assign(Object.assign({}, baseCompilerOptions), { jsx: monaco.languages.typescript.JsxEmit.React, reactNamespace: 'React', typeRoots: ['node_modules/@types'] }));
+        // JavaScript-specific options
+        jsDefaults.setCompilerOptions(Object.assign(Object.assign({}, baseCompilerOptions), { checkJs: false }));
+        // Register custom completion provider for Database suggestions
+        monaco.languages.registerCompletionItemProvider(['javascript', 'typescript'], {
+            provideCompletionItems: () => {
+                const suggestions = [
+                    {
+                        label: 'Database',
+                        kind: monaco.languages.CompletionItemKind.Class,
+                        insertText: 'Database',
+                        documentation: 'Static Database Client for Nuraly Database Manager',
+                        detail: 'class Database',
+                    },
+                    {
+                        label: 'Database.select',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.select(${1:"tableName"}, {${2:}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Select data from a table with optional criteria and relations',
+                        detail: '(method) Database.select(tableName: string, options?: SelectOptions): Promise<any>',
+                    },
+                    {
+                        label: 'Database.insert',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.insert(${1:"tableName"}, ${2:{}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Insert data into a table',
+                        detail: '(method) Database.insert(tableName: string, data: Record<string, any>): Promise<any>',
+                    },
+                    {
+                        label: 'Database.update',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.update(${1:"tableName"}, ${2:{}}, ${3:{}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Update data in a table',
+                        detail: '(method) Database.update(tableName: string, data: Record<string, any>, criteria: Record<string, any>): Promise<any>',
+                    },
+                    {
+                        label: 'Database.delete',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.delete(${1:"tableName"}, ${2:{}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Delete data from a table',
+                        detail: '(method) Database.delete(tableName: string, criteria: Record<string, any>): Promise<any>',
+                    },
+                    {
+                        label: 'Database.createTable',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.createTable(${1:"tableName"}, {\n  ${2:field}: { type: ${3:"varchar"}, nullable: ${4:false} }\n})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Create a new table with specified schema',
+                        detail: '(method) Database.createTable(tableName: string, schema: TableSchema, options?: Record<string, any>): Promise<any>',
+                    },
+                    {
+                        label: 'Database.paginate',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.paginate(${1:"tableName"}, ${2:1}, ${3:10}, ${4:{}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Get paginated results with metadata',
+                        detail: '(method) Database.paginate(tableName: string, page?: number, pageSize?: number, options?: SelectOptions): Promise<PaginationResult<any>>',
+                    },
+                    {
+                        label: 'Database.schemaQuery',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.schemaQuery(${1:"LIST_TABLES"}${2:, "tableName"})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Execute schema queries for database introspection',
+                        detail: '(method) Database.schemaQuery(type: string, tableName?: string): Promise<any>',
+                    },
+                    {
+                        label: 'Database.join',
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        insertText: 'Database.join(${1:"mainTable"}, [\n  { table: ${2:"joinTable"}, on: ${3:"field1 = field2"}, type: ${4:"inner"} }\n], ${5:{}})',
+                        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                        documentation: 'Perform complex join queries',
+                        detail: '(method) Database.join(mainTable: string, joins: JoinDefinition[], options?: Record<string, any>): Promise<any>',
+                    },
+                ];
+                return { suggestions };
+            },
+        });
+        // Register hover provider for documentation
+        monaco.languages.registerHoverProvider(['javascript', 'typescript'], {
+            provideHover: (model, position) => {
+                const word = model.getWordAtPosition(position);
+                if (!word)
+                    return;
+                const hoverDocs = {
+                    Database: {
+                        contents: [
+                            { value: '**Database**' },
+                            { value: 'Static Database Client for Nuraly Database Manager' },
+                            { value: 'Provides a comprehensive interface for database operations including:' },
+                            { value: '- Table management (create, drop, schema operations)' },
+                            { value: '- Data operations (select, insert, update, delete)' },
+                            { value: '- Advanced queries (joins, aggregations, pagination)' },
+                            { value: '- Schema introspection and management' },
+                        ],
+                    },
+                };
+                return hoverDocs[word.word] || null;
+            },
+        });
+    }
+    updated(changedProperties) {
+        var _a;
+        super.updated(changedProperties);
+        if (!this.isEditorReady || !this.editor)
+            return;
+        // Apply theme from mixin on every update (handles data-theme changes)
+        this.applyThemeFromMixin();
+        if (changedProperties.has('code') && this.code !== changedProperties.get('code')) {
+            const model = this.editor.getModel();
+            if (model && this.code !== this.getValue()) {
+                try {
+                    const cursorPosition = this.editor.getPosition();
+                    this.editor.setValue((_a = this.code) !== null && _a !== void 0 ? _a : '');
+                    if (cursorPosition) {
+                        this.editor.setPosition(cursorPosition);
+                    }
+                }
+                catch (_b) {
+                    // Monaco services might be temporarily unavailable
+                }
+            }
+        }
+        if (changedProperties.has('readonly')) {
+            try {
+                this.editor.updateOptions({ readOnly: this.readonly });
+            }
+            catch (_c) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('language') && this.editor.getModel()) {
+            try {
+                monaco.editor.setModelLanguage(this.editor.getModel(), this.language || 'plaintext');
+            }
+            catch (_d) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('theme')) {
+            try {
+                monaco.editor.setTheme(this.theme);
+            }
+            catch (_e) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('fontSize')) {
+            try {
+                this.editor.updateOptions({ fontSize: this.fontSize });
+            }
+            catch (_f) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('lineNumbers')) {
+            try {
+                this.editor.updateOptions({ lineNumbers: this.lineNumbers ? 'on' : 'off' });
+            }
+            catch (_g) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('minimap')) {
+            try {
+                this.editor.updateOptions({ minimap: { enabled: this.minimap } });
+            }
+            catch (_h) {
+                // Ignore
+            }
+        }
+        if (changedProperties.has('wordWrap')) {
+            try {
+                this.editor.updateOptions({ wordWrap: this.wordWrap ? 'on' : 'off' });
+            }
+            catch (_j) {
+                // Ignore
+            }
+        }
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        // Clean up Monaco editor
+        if (this.editor) {
+            const model = this.editor.getModel();
+            this.editor.dispose();
+            model === null || model === void 0 ? void 0 : model.dispose();
+            this.editor = undefined;
+        }
+        this.isEditorReady = false;
+    }
+};
+NrCodeEditorElement.styles = styles;
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NrCodeEditorElement.prototype, "readonly", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], NrCodeEditorElement.prototype, "theme", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], NrCodeEditorElement.prototype, "language", void 0);
+__decorate([
+    property({ type: String })
+], NrCodeEditorElement.prototype, "code", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'line-numbers' })
+], NrCodeEditorElement.prototype, "lineNumbers", void 0);
+__decorate([
+    property({ type: Boolean })
+], NrCodeEditorElement.prototype, "minimap", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'word-wrap' })
+], NrCodeEditorElement.prototype, "wordWrap", void 0);
+__decorate([
+    property({ type: Number, attribute: 'font-size' })
+], NrCodeEditorElement.prototype, "fontSize", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'ai-completions' })
+], NrCodeEditorElement.prototype, "aiCompletions", void 0);
+__decorate([
+    property({ type: String, attribute: 'completions-endpoint' })
+], NrCodeEditorElement.prototype, "completionsEndpoint", void 0);
+__decorate([
+    property({ attribute: false })
+], NrCodeEditorElement.prototype, "extraTypeDefinitions", void 0);
+NrCodeEditorElement = __decorate([
+    customElement('nr-code-editor')
+], NrCodeEditorElement);
+export { NrCodeEditorElement };
+//# sourceMappingURL=code-editor.component.js.map

package/dist/src/components/code-editor/code-editor.style.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=code-editor.style.d.ts.map

package/dist/src/components/code-editor/code-editor.style.js

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+import { css } from 'lit';
+export const styles = css `
+  :host {
+    --nuraly-code-editor-width: 100%;
+    --nuraly-code-editor-height: 100%;
+    --nuraly-code-editor-min-height: 0;
+    --nuraly-code-editor-max-height: none;
+    --nuraly-code-editor-border-radius: 4px;
+    --nuraly-code-editor-border: 1px solid var(--nuraly-border-color, #e0e0e0);
+
+    display: block;
+    width: var(--nuraly-code-editor-width);
+    height: var(--nuraly-code-editor-height);
+  }
+
+  :host([hidden]) {
+    display: none;
+  }
+
+  .editor-container {
+    width: 100%;
+    height: 100%;
+    min-height: var(--nuraly-code-editor-min-height);
+    max-height: var(--nuraly-code-editor-max-height);
+    border-radius: var(--nuraly-code-editor-border-radius);
+    overflow: hidden;
+  }
+
+  main {
+    width: 100%;
+    height: 100%;
+  }
+`;
+//# sourceMappingURL=code-editor.style.js.map

package/dist/src/components/code-editor/code-editor.types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+export declare const CODE_EDITOR_THEME: {
+    readonly Light: "vs";
+    readonly Dark: "vs-dark";
+    readonly HighContrastDark: "hc-black";
+    readonly HighContrastLight: "hc-light";
+};
+export type CodeEditorTheme = typeof CODE_EDITOR_THEME[keyof typeof CODE_EDITOR_THEME];
+export declare const CODE_EDITOR_LANGUAGE: {
+    readonly JavaScript: "javascript";
+    readonly TypeScript: "typescript";
+    readonly JSON: "json";
+    readonly HTML: "html";
+    readonly CSS: "css";
+    readonly Markdown: "markdown";
+    readonly Python: "python";
+    readonly PlainText: "plaintext";
+};
+export type CodeEditorLanguage = typeof CODE_EDITOR_LANGUAGE[keyof typeof CODE_EDITOR_LANGUAGE] | string;
+export interface CodeEditorChangeEventDetail {
+    value: string;
+}
+export interface CodeEditorKeyEventDetail {
+    event: KeyboardEvent;
+    key: string;
+    code: string;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+}
+export interface CodeEditorReadyEventDetail {
+    editor: unknown;
+}
+//# sourceMappingURL=code-editor.types.d.ts.map

package/dist/src/components/code-editor/code-editor.types.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+export const CODE_EDITOR_THEME = {
+    Light: 'vs',
+    Dark: 'vs-dark',
+    HighContrastDark: 'hc-black',
+    HighContrastLight: 'hc-light'
+};
+export const CODE_EDITOR_LANGUAGE = {
+    JavaScript: 'javascript',
+    TypeScript: 'typescript',
+    JSON: 'json',
+    HTML: 'html',
+    CSS: 'css',
+    Markdown: 'markdown',
+    Python: 'python',
+    PlainText: 'plaintext'
+};
+//# sourceMappingURL=code-editor.types.js.map

package/dist/src/components/code-editor/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+export * from './code-editor.component.js';
+export * from './code-editor.types.js';
+export { styles as codeEditorStyles } from './code-editor.style.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/code-editor/index.js

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly
+ * SPDX-License-Identifier: MIT
+ */
+export * from './code-editor.component.js';
+export * from './code-editor.types.js';
+export { styles as codeEditorStyles } from './code-editor.style.js';
+//# sourceMappingURL=index.js.map