@nuraly/runtime 0.1.4 → 0.1.5

package/dist/CodeEditor-BiNku87K.js

@@ -0,0 +1,808 @@
+import { css, LitElement, html } from 'lit';
+import { property, customElement } from 'lit/decorators.js';
+import { createRef, ref } from 'lit/directives/ref.js';
+import * as monaco from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/esm/vs/editor/editor.main.js';
+import { registerCompletion } from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monacopilot/build/index.mjs';
+import styles from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/min/vs/editor/editor.main.css?inline';
+import editorWorker from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/esm/vs/editor/editor.worker.js?worker';
+import tsWorker from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/esm/vs/language/typescript/ts.worker.js?worker';
+import htmlWorker from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/esm/vs/language/html/html.worker.js?worker';
+import jsonWorker from '/Users/aymen/Desktop/projects/nuraly/stack/services/studio/node_modules/monaco-editor/esm/vs/language/json/json.worker.js?worker';
+
+const databaseTypeDefinitions = `
+/**
+ * Database configuration options
+ */
+interface DatabaseOptions {
+    timeout?: number;
+    headers?: Record<string, string>;
+    [key: string]: any;
+}
+
+/**
+ * Table schema definition for creating tables
+ */
+interface TableSchema {
+    [key: string]: {
+        type: string;
+        nullable?: boolean;
+        default?: any;
+        [key: string]: any;
+    };
+}
+
+/**
+ * Options for select queries including relations and criteria
+ */
+interface SelectOptions {
+    relations?: RelationDefinition[];
+    criteria?: Record<string, any>;
+    fields?: string[];
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDirection?: 'ASC' | 'DESC';
+    [key: string]: any;
+}
+
+/**
+ * Relation definition for joins
+ */
+interface RelationDefinition {
+    table: string;
+    localField: string;
+    foreignField: string;
+    type: 'inner' | 'left' | 'right' | 'outer';
+}
+
+/**
+ * Join definition for complex queries
+ */
+interface JoinDefinition {
+    table: string;
+    on: string;
+    type?: string;
+}
+
+/**
+ * Batch operation definition
+ */
+interface BatchOperation {
+    method: string;
+    table: string;
+    data?: Record<string, any>;
+    criteria?: Record<string, any>;
+    options?: SelectOptions;
+}
+
+/**
+ * Pagination result with metadata
+ */
+interface PaginationResult<T> {
+    data: T[];
+    count: number;
+    pagination: {
+        currentPage: number;
+        pageSize: number;
+        totalRecords: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+    };
+}
+
+/**
+ * Backup data structure
+ */
+interface BackupData {
+    tableName: string;
+    timestamp: string;
+    recordCount: number;
+    data: Record<string, any>[];
+}
+
+/**
+ * Static Database Client for Nuraly Database Manager
+ * 
+ * A comprehensive JavaScript class that provides a clean static interface for all database operations
+ * including table management, data operations, joins, and advanced queries.
+ */
+declare class Database {
+    /**
+     * Configure the Database client
+     * @param baseUrl The base URL of the database API (default: /api/v1/database)
+     * @param options Additional configuration options
+     */
+    static configure(baseUrl?: string, options?: DatabaseOptions): void;
+
+    // HEALTH & INFO METHODS
+    /**
+     * Check the health status of the database service
+     * @returns Health status
+     */
+    static health(): Promise<any>;
+
+    /**
+     * Get database connection information and metadata
+     * @returns Database info
+     */
+    static getInfo(): Promise<any>;
+
+    // TABLE MANAGEMENT METHODS
+    /**
+     * Create a new table with specified schema
+     * @param tableName Name of the table to create
+     * @param schema Table schema definition
+     * @param options Additional options
+     * @returns Creation result
+     */
+    static createTable(tableName: string, schema: TableSchema, options?: Record<string, any>): Promise<any>;
+
+    /**
+     * Update existing table schema (add columns)
+     * @param tableName Name of the table to update
+     * @param schema New columns to add
+     * @returns Update result
+     */
+    static updateSchema(tableName: string, schema: TableSchema): Promise<any>;
+
+    /**
+     * Drop a table
+     * @param tableName Name of the table to drop
+     * @returns Drop result
+     */
+    static dropTable(tableName: string): Promise<any>;
+
+    /**
+     * List all tables in the database
+     * @returns List of tables
+     */
+    static listTables(): Promise<any>;
+
+    /**
+     * Get table schema information
+     * @param tableName Name of the table
+     * @returns Table schema
+     */
+    static getTableSchema(tableName: string): Promise<any>;
+
+    /**
+     * Execute comprehensive schema queries for database introspection
+     * @param type Type of schema query (LIST_TABLES, DESCRIBE_TABLE, TABLE_EXISTS, GET_INFO, LIST_INDEXES, GET_CONSTRAINTS, GET_FOREIGN_KEYS)
+     * @param tableName Name of the table (optional, required for table-specific queries)
+     * @returns Schema query result
+     */
+    static schemaQuery(type: string, tableName?: string): Promise<any>;
+
+    /**
+     * Check if a table exists in the database
+     * @param tableName Name of the table to check
+     * @returns True if table exists, false otherwise
+     */
+    static tableExists(tableName: string): Promise<boolean>;
+
+    /**
+     * Get all column information for a specific table
+     * @param tableName Name of the table
+     * @returns Column information including types, constraints, and defaults
+     */
+    static columns(tableName: string): Promise<any>;
+
+    /**
+     * Get database information and metadata
+     * @returns Database information and metadata
+     */
+    static getDatabaseInfo(): Promise<any>;
+
+    /**
+     * Get table constraints (primary keys, foreign keys, unique constraints, etc.)
+     * @param tableName Name of the table
+     * @returns Table constraints information
+     */
+    static getConstraints(tableName: string): Promise<any>;
+
+    /**
+     * Get foreign key relationships for a table
+     * @param tableName Name of the table
+     * @returns Foreign key information and relationships
+     */
+    static getForeignKeys(tableName: string): Promise<any>;
+
+    // DATA OPERATION METHODS
+    /**
+     * Insert data into a table
+     * @param tableName Name of the table
+     * @param data Data to insert
+     * @returns Insert result
+     */
+    static insert(tableName: string, data: Record<string, any>): Promise<any>;
+
+    /**
+     * Bulk insert multiple records
+     * @param tableName Name of the table
+     * @param records Array of records to insert
+     * @returns Array of insert results
+     */
+    static bulkInsert(tableName: string, records: Record<string, any>[]): Promise<any[]>;
+
+    /**
+     * Unified select method that handles both regular queries and queries with relations (joins)
+     * @param tableName Name of the table
+     * @param options Query options
+     * @returns Select result
+     */
+    static select(tableName: string, options?: SelectOptions): Promise<any>;
+
+    /**
+     * Update data in a table
+     * @param tableName Name of the table
+     * @param data Data to update
+     * @param criteria Update criteria
+     * @returns Update result
+     */
+    static update(tableName: string, data: Record<string, any>, criteria: Record<string, any>): Promise<any>;
+
+    /**
+     * Delete data from a table
+     * @param tableName Name of the table
+     * @param criteria Delete criteria
+     * @returns Delete result
+     */
+    static delete(tableName: string, criteria: Record<string, any>): Promise<any>;
+
+    // AGGREGATION & ANALYSIS METHODS
+    /**
+     * Count records in a table
+     * @param tableName Name of the table
+     * @param criteria Count criteria (optional)
+     * @returns Count result
+     */
+    static count(tableName: string, criteria?: Record<string, any>): Promise<any>;
+
+    /**
+     * Calculate sum of a field
+     * @param tableName Name of the table
+     * @param field Field to sum
+     * @param criteria Filter criteria (optional)
+     * @returns Sum result
+     */
+    static sum(tableName: string, field: string, criteria?: Record<string, any>): Promise<any>;
+
+    /**
+     * Calculate average of a field
+     * @param tableName Name of the table
+     * @param field Field to average
+     * @param criteria Filter criteria (optional)
+     * @returns Average result
+     */
+    static avg(tableName: string, field: string, criteria?: Record<string, any>): Promise<any>;
+
+    /**
+     * Find maximum value of a field
+     * @param tableName Name of the table
+     * @param field Field to find max
+     * @param criteria Filter criteria (optional)
+     * @returns Max result
+     */
+    static max(tableName: string, field: string, criteria?: Record<string, any>): Promise<any>;
+
+    /**
+     * Find minimum value of a field
+     * @param tableName Name of the table
+     * @param field Field to find min
+     * @param criteria Filter criteria (optional)
+     * @returns Min result
+     */
+    static min(tableName: string, field: string, criteria?: Record<string, any>): Promise<any>;
+
+    /**
+     * Group by field with aggregation
+     * @param tableName Name of the table
+     * @param groupField Field to group by
+     * @param aggregateFields Fields to aggregate
+     * @param aggregateOperations Aggregation operations
+     * @param criteria Filter criteria (optional)
+     * @returns Group by result
+     */
+    static groupBy(tableName: string, groupField: string, aggregateFields: string[], aggregateOperations: string[], criteria?: Record<string, any>): Promise<any>;
+
+    // INDEX MANAGEMENT METHODS
+    /**
+     * Create an index on table fields
+     * @param tableName Name of the table
+     * @param indexName Name of the index
+     * @param fields Fields to index
+     * @param indexType Type of index (btree, hash, etc.)
+     * @returns Index creation result
+     */
+    static createIndex(tableName: string, indexName: string, fields: string[], indexType?: string): Promise<any>;
+
+    /**
+     * Drop an index
+     * @param tableName Name of the table
+     * @param indexName Name of the index to drop
+     * @returns Index drop result
+     */
+    static dropIndex(tableName: string, indexName: string): Promise<any>;
+
+    /**
+     * List all indexes for a table
+     * @param tableName Name of the table
+     * @returns List of indexes
+     */
+    static listIndexes(tableName: string): Promise<any>;
+
+    // ADVANCED QUERY METHODS
+    /**
+     * Execute raw SQL query
+     * @param sql SQL query to execute
+     * @param parameters Query parameters (optional)
+     * @returns Query result
+     */
+    static executeSQL(sql: string, parameters?: any[]): Promise<any>;
+
+    /**
+     * Perform a complex join query
+     * @param mainTable Main table for the join
+     * @param joins Array of join specifications
+     * @param options Additional query options
+     * @returns Join result
+     */
+    static join(mainTable: string, joins: JoinDefinition[], options?: Record<string, any>): Promise<any>;
+
+    // BATCH OPERATION METHODS
+    /**
+     * Execute multiple operations in sequence
+     * @param operations Array of operations to execute
+     * @returns Array of results
+     */
+    static batch(operations: BatchOperation[]): Promise<any[]>;
+
+    // UTILITY METHODS
+    /**
+     * Get paginated results
+     * @param tableName Name of the table
+     * @param page Page number (1-based)
+     * @param pageSize Number of records per page
+     * @param options Additional query options
+     * @returns Paginated results with metadata
+     */
+    static paginate(tableName: string, page?: number, pageSize?: number, options?: SelectOptions): Promise<PaginationResult<any>>;
+
+    /**
+     * Search records with text matching
+     * @param tableName Name of the table
+     * @param searchTerm Term to search for
+     * @param searchFields Fields to search in
+     * @param options Additional options
+     * @returns Search results
+     */
+    static search(tableName: string, searchTerm: string, searchFields: string[], options?: SelectOptions): Promise<any>;
+
+    /**
+     * Backup table data to JSON
+     * @param tableName Name of the table to backup
+     * @returns Backup data
+     */
+    static backup(tableName: string): Promise<BackupData>;
+
+    /**
+     * Restore table data from backup
+     * @param backupData Backup data object
+     * @param clearFirst Whether to clear existing data first
+     * @returns Restore result
+     */
+    static restore(backupData: BackupData, clearFirst?: boolean): Promise<any>;
+}
+
+declare const Database: typeof Database;
+`;
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+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();
+    }
+  };
+}
+let CodeEditor = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.isEditorReady = false;
+    this.theme = "";
+    this.container = createRef();
+  }
+  render() {
+    return html`
+      <style>
+        ${styles}
+      </style>
+      <main ${ref(this.container)}></main>
+    `;
+  }
+  /**
+   * Returns the current code contents
+   */
+  getValue() {
+    return this.editor?.getValue() ?? "";
+  }
+  /**
+   * Allows external code to update various Monaco editor options
+   */
+  setOptions(value) {
+    this.editor?.updateOptions(value);
+  }
+  /**
+   * Set up custom IntelliSense for TypeScript/JavaScript
+   */
+  setupCustomIntelliSense() {
+    monaco.languages.typescript.typescriptDefaults.addExtraLib(
+      databaseTypeDefinitions,
+      "database-types.d.ts"
+    );
+    monaco.languages.typescript.javascriptDefaults.addExtraLib(
+      databaseTypeDefinitions,
+      "database-types.d.ts"
+    );
+    monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+      target: monaco.languages.typescript.ScriptTarget.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,
+      reactNamespace: "React",
+      allowJs: true,
+      typeRoots: ["node_modules/@types"]
+    });
+    monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+      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,
+      checkJs: false
+    });
+    monaco.languages.registerCompletionItemProvider(["javascript", "typescript"], {
+      provideCompletionItems: (model, position) => {
+        const suggestions = [];
+        suggestions.push({
+          label: "Database",
+          kind: monaco.languages.CompletionItemKind.Class,
+          insertText: "Database",
+          documentation: "Static Database Client for Nuraly Database Manager",
+          detail: "class Database"
+        });
+        const dbOperations = [
+          {
+            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>"
+          }
+        ];
+        suggestions.push(...dbOperations);
+        return { suggestions };
+      }
+    });
+    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" },
+              { value: '```typescript\n// Configure the client\nDatabase.configure("/api/v1/database");\n\n// Create a table\nawait Database.createTable("users", {\n  name: { type: "varchar", nullable: false },\n  email: { type: "varchar", nullable: false }\n});\n\n// Insert data\nawait Database.insert("users", {\n  name: "John Doe",\n  email: "john@example.com"\n});\n```' }
+            ]
+          }
+        };
+        return hoverDocs[word.word] || null;
+      }
+    });
+  }
+  /**
+   * Create the Monaco editor once the element has rendered
+   */
+  firstUpdated() {
+    if (!this.container.value) {
+      console.error("CodeEditor: Container element not available in firstUpdated");
+      return;
+    }
+    monaco.languages.register({ id: "mylang" });
+    monaco.languages.setMonarchTokensProvider("mylang", {
+      tokenizer: {
+        root: [
+          [/#.*$/, "comment"],
+          [/\b(begin|end|if|else|while)\b/, "keyword"],
+          [/[=+\-*/]/, "operator"],
+          [/\d+/, "number"]
+        ]
+      }
+    });
+    try {
+      this.editor = monaco.editor.create(this.container.value, {
+        value: this.getCode(),
+        language: this.getLang(),
+        theme: this.getTheme(),
+        fontSize: 13,
+        automaticLayout: true,
+        readOnly: this.readonly ?? false
+      });
+      this.isEditorReady = true;
+    } catch (error) {
+      console.error("CodeEditor: Failed to create editor instance", error);
+      return;
+    }
+    this.setupCustomIntelliSense();
+    registerCompletion(monaco, this.editor, {
+      language: this.getLang(),
+      // Your API endpoint for handling completion requests
+      endpoint: "/api/v1/copilot/completion"
+    });
+    this.editor.getModel()?.onDidChangeContent(() => {
+      this.dispatchEvent(
+        new CustomEvent("change", { detail: { value: this.getValue() } })
+      );
+    });
+    this.registerKeyboardEvents();
+    window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
+      monaco.editor.setTheme(this.getTheme());
+    });
+  }
+  /**
+   * Register keyboard event handlers for the editor
+   */
+  registerKeyboardEvents() {
+    if (!this.editor) return;
+    this.editor.onKeyDown((e) => {
+      this.dispatchEvent(
+        new CustomEvent("editor-keydown", {
+          detail: {
+            event: e,
+            key: e.browserEvent.key,
+            code: e.browserEvent.code,
+            ctrlKey: e.browserEvent.ctrlKey,
+            shiftKey: e.browserEvent.shiftKey,
+            altKey: e.browserEvent.altKey,
+            metaKey: e.browserEvent.metaKey
+          }
+        })
+      );
+    });
+    this.editor.onKeyUp((e) => {
+      this.dispatchEvent(
+        new CustomEvent("editor-keyup", {
+          detail: {
+            event: e,
+            key: e.browserEvent.key,
+            code: e.browserEvent.code,
+            ctrlKey: e.browserEvent.ctrlKey,
+            shiftKey: e.browserEvent.shiftKey,
+            altKey: e.browserEvent.altKey,
+            metaKey: e.browserEvent.metaKey
+          }
+        })
+      );
+    });
+  }
+  /**
+   * Dispose of the editor and its model when the element is removed
+   * from the DOM. This prevents stale listeners from piling up.
+   */
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    if (this.editor) {
+      const model = this.editor.getModel();
+      this.editor.dispose();
+      model?.dispose();
+      this.editor = void 0;
+    }
+    this.isEditorReady = false;
+  }
+  /**
+   * Whenever the `code` property changes, update the editor’s text if needed
+   */
+  update(changedProperties) {
+    super.update(changedProperties);
+    if (!this.isEditorReady) {
+      return;
+    }
+    if (changedProperties.has("code") && this.code !== changedProperties.get("code")) {
+      if (!this.editor) {
+        return;
+      }
+      const model = this.editor.getModel();
+      if (!model) {
+        return;
+      }
+      const cursorPosition = this.editor.getPosition();
+      if (this.code !== this.getValue()) {
+        try {
+          this.editor.setValue(this.code ?? "");
+          if (cursorPosition) {
+            this.editor.setPosition(cursorPosition);
+          }
+        } catch (e) {
+        }
+      }
+    }
+    if (changedProperties.has("readonly") && this.readonly !== changedProperties.get("readonly")) {
+      try {
+        this.editor?.updateOptions({
+          readOnly: this.readonly ?? false
+        });
+      } catch (e) {
+      }
+    }
+    if (changedProperties.has("language") && this.language !== changedProperties.get("language")) {
+      try {
+        if (this.editor && this.editor.getModel()) {
+          monaco.editor.setModelLanguage(
+            this.editor.getModel(),
+            this.language || "plaintext"
+          );
+        }
+      } catch (e) {
+      }
+    }
+    if (changedProperties.has("theme") && this.theme !== changedProperties.get("theme")) {
+      try {
+        this.editor?.updateOptions({
+          theme: this.theme
+        });
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * If the user hasn't passed any `code`, we look for a <script> child
+   * or fallback to an empty string
+   */
+  getCode() {
+    if (this.code) return this.code;
+    const file = this.getFile();
+    return file ? file.innerHTML.trim() : "";
+  }
+  /**
+   * If the user hasn't passed any `language`, we look for a <script> child
+   * or fallback to "plaintext"
+   */
+  getLang() {
+    if (this.language) return this.language;
+    const file = this.getFile();
+    if (!file) return "plaintext";
+    const type = file.getAttribute("type") || "text/plain";
+    return type.split("/").pop() || "plaintext";
+  }
+  /**
+   * Figure out which theme Monaco should use
+   */
+  getTheme() {
+    if (this.theme) return this.theme;
+    return this.isDark() ? "vs-dark" : "vs-light";
+  }
+  isDark() {
+    return window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches;
+  }
+  /**
+   * If we have a <script> child, return it (this is just a convenience to allow:
+   * <code-editor><script type="text/javascript">const x=1;<\/script></code-editor>)
+   */
+  getFile() {
+    return this.children.length > 0 ? this.children[0] : null;
+  }
+};
+CodeEditor.styles = css`
+      :host {
+          --editor-width: 100%;
+          --editor-height: 100%;
+      }
+      main {
+          width: var(--editor-width);
+          height: var(--editor-height);
+      }
+  `;
+__decorateClass([
+  property({ type: Boolean, attribute: "readonly" })
+], CodeEditor.prototype, "readonly", 2);
+__decorateClass([
+  property()
+], CodeEditor.prototype, "theme", 2);
+__decorateClass([
+  property()
+], CodeEditor.prototype, "language", 2);
+__decorateClass([
+  property()
+], CodeEditor.prototype, "code", 2);
+CodeEditor = __decorateClass([
+  customElement("code-editor")
+], CodeEditor);
+
+export { CodeEditor };