@adminide-stack/extension-api 12.0.4-alpha.92 → 13.0.1-alpha.0

package/lib/services/code/javascript/jslibrary/autocomplete/definitions/lodash.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lodash.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/code/javascript/jslibrary/autocomplete/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Autocomplete definitions for JavaScript code completion
+ * This module exports Tern definition objects for various libraries and APIs
+ */
+import base64jsDefinitions from './definitions/base64-js.json';
+import browserDefinitions from './definitions/browser.json';
+import ecmascriptDefinitions from './definitions/ecmascript.json';
+import lodashDefinitions from './definitions/lodash.json';
+/**
+ * Type definition for Tern definition objects
+ */
+export interface TernDefinition {
+    '!name': string;
+    '!define'?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Available autocomplete definition sets
+ */
+export declare const AUTOCOMPLETE_DEFINITIONS: Record<string, TernDefinition>;
+/**
+ * Get a specific definition by name
+ */
+export declare function getDefinition(name: string): TernDefinition | undefined;
+/**
+ * Get all available definition names
+ */
+export declare function getAvailableDefinitions(): string[];
+/**
+ * Get multiple definitions by names
+ */
+export declare function getDefinitions(names: string[]): TernDefinition[];
+/**
+ * Get default definitions that should be included in most contexts
+ */
+export declare function getDefaultDefinitions(): TernDefinition[];
+/**
+ * Get library-specific definitions (non-core)
+ */
+export declare function getLibraryDefinitions(): TernDefinition[];
+/**
+ * Create a combined definition object from multiple definitions
+ */
+export declare function combineDefinitions(definitions: TernDefinition[]): TernDefinition;
+export { base64jsDefinitions, browserDefinitions, ecmascriptDefinitions, lodashDefinitions };

package/lib/services/code/javascript/jslibrary/autocomplete/index.js

@@ -0,0 +1,56 @@
+import base64jsDefinitions from'./definitions/base64-js.json.js';import browserDefinitions from'./definitions/browser.json.js';import ecmascriptDefinitions from'./definitions/ecmascript.json.js';import lodashDefinitions from'./definitions/lodash.json.js';/**
+ * Autocomplete definitions for JavaScript code completion
+ * This module exports Tern definition objects for various libraries and APIs
+ */
+/**
+ * Available autocomplete definition sets
+ */
+const AUTOCOMPLETE_DEFINITIONS = {
+  'base64-js': base64jsDefinitions,
+  browser: browserDefinitions,
+  ecmascript: ecmascriptDefinitions,
+  lodash: lodashDefinitions
+};
+/**
+ * Get a specific definition by name
+ */
+function getDefinition(name) {
+  return AUTOCOMPLETE_DEFINITIONS[name];
+}
+/**
+ * Get default definitions that should be included in most contexts
+ */
+function getDefaultDefinitions() {
+  return [ecmascriptDefinitions, browserDefinitions];
+}
+/**
+ * Get library-specific definitions (non-core)
+ */
+function getLibraryDefinitions() {
+  return [lodashDefinitions, base64jsDefinitions];
+}
+/**
+ * Create a combined definition object from multiple definitions
+ */
+function combineDefinitions(definitions) {
+  const combined = {
+    '!name': 'combined',
+    '!define': {}
+  };
+  definitions.forEach(def => {
+    // Merge top-level properties (excluding metadata)
+    Object.keys(def).forEach(key => {
+      if (key.startsWith('!')) {
+        if (key === '!define' && combined['!define']) {
+          // Merge !define objects
+          Object.assign(combined['!define'], def['!define']);
+        }
+        // Skip other metadata properties to avoid conflicts
+        return;
+      }
+      // Add library properties to the combined definition
+      combined[key] = def[key];
+    });
+  });
+  return combined;
+}export{AUTOCOMPLETE_DEFINITIONS,base64jsDefinitions,browserDefinitions,combineDefinitions,ecmascriptDefinitions,getDefaultDefinitions,getDefinition,getLibraryDefinitions,lodashDefinitions};//# sourceMappingURL=index.js.map

package/lib/services/code/javascript/jslibrary/autocomplete/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../src/services/code/javascript/jslibrary/autocomplete/index.ts"],"sourcesContent":[null],"names":[],"mappings":"+PAAA;;;AAGG;AAgBH;;AAEG;AACI,MAAM,wBAAwB,GAAmC;AACpE,EAAA,WAAA,EAAW,mBAAE;AACb,EAAA,OAAA,EAAO,kBAAE;AACT,EAAA,UAAA,EAAU,qBAAE;AACZ,EAAA,MAAA,EAAM;;AAGV;;AAEG;AACG,SAAU,aAAa,CAAC,IAAY,EAAA;AACtC,EAAA,OAAA,wBAAO,CAAA,IAAyB,CAAA;AACpC;AAgBA;;AAEG;SACa,qBAAqB,GAAA;AACjC,EAAA,OAAA,CAAA,qBAAQ,EAAuC,kBAAE,CAAA;AACrD;AAEA;;AAEG;SACa,qBAAqB,GAAA;AACjC,EAAA,OAAA,CAAA,iBAAQ,EAAmC,mBAAE,CAAA;AACjD;AAEA;;AAEG;AACG,SAAU,kBAAkB,CAAC,WAA6B,EAAA;AAC5D,EAAA,MAAA,WAAc;AACV,IAAA,OAAA,EAAA,UAAS;AACT,IAAA,SAAA,EAAA;;AAGJ,EAAA,WAAA,CAAA,OAAY,CAAA,GAAS;;UAEjB,CAAA,IAAO,CAAA,GAAI,CAAC,CAAA,OAAK,CAAA,GAAO,IAAE;AACtB,MAAA,IAAA,GAAA,CAAA,UAAQ,CAAA,GAAA,CAAA,EAAW;oBACX,SAAQ,IAAA,QAAa,UAAS,CAAA,EAAA;;AAE9B,UAAA,MAAA,CAAA,MAAA,CAAA,QAAO,CAAM,SAAS,CAAC,EAAA,GAAA,CAAA,SAAe,CAAC,CAAA;;;;;;cAO/C,CAAA,GAAA,CAAA,MAAa,CAAA;AACjB,IAAA,CAAA,CAAA;AACJ,EAAA,CAAA,CAAA;AAEA,EAAA,OAAA;AACJ"}

package/lib/services/code/javascript/jslibrary/autocomplete-manager.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Autocomplete Manager for JavaScript Code Intelligence
+ * Integrates Tern definitions with library management for comprehensive autocomplete support
+ */
+import type { Def } from 'tern';
+import { type TernDefinition } from './autocomplete';
+/**
+ * Configuration for autocomplete behavior
+ */
+export interface AutocompleteConfig {
+    includeDefaults: boolean;
+    includeLibraries: boolean;
+    enableDynamicLibraries: boolean;
+    customDefinitions: string[];
+}
+/**
+ * Manages autocomplete definitions and provides intelligent code completion
+ */
+export declare class AutocompleteManager {
+    private config;
+    private cachedDefinitions;
+    private lastUpdateTime;
+    private readonly cacheTimeout;
+    constructor(config?: Partial<AutocompleteConfig>);
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<AutocompleteConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): AutocompleteConfig;
+    /**
+     * Invalidate the cached definitions
+     */
+    invalidateCache(): void;
+    /**
+     * Get comprehensive autocomplete definitions
+     */
+    getDefinitions(): TernDefinition;
+    /**
+     * Get definitions for dynamically loaded libraries
+     */
+    private getDynamicLibraryDefinitions;
+    /**
+     * Get Tern-compatible definition object
+     */
+    getTernDef(): Def;
+    /**
+     * Get available definition names
+     */
+    getAvailableDefinitions(): string[];
+    /**
+     * Check if a definition is available
+     */
+    hasDefinition(name: string): boolean;
+    /**
+     * Get completions for a specific context
+     */
+    getCompletions(context: {
+        text: string;
+        position: number;
+        scope?: string[];
+    }): Promise<{
+        completions: Array<{
+            name: string;
+            type?: string;
+            doc?: string;
+            url?: string;
+        }>;
+        isIncomplete: boolean;
+    }>;
+    /**
+     * Extract completions from definition object
+     */
+    private extractCompletions;
+    /**
+     * Get type information for a symbol
+     */
+    getTypeInfo(symbol: string, scope?: string[]): {
+        type?: string;
+        doc?: string;
+        url?: string;
+    } | null;
+    /**
+     * Find symbol information in definitions
+     */
+    private findSymbolInfo;
+    /**
+     * Refresh definitions (force cache invalidation and reload)
+     */
+    refresh(): void;
+}
+export declare const autocompleteManager: AutocompleteManager;

package/lib/services/code/javascript/jslibrary/autocomplete-manager.js

@@ -0,0 +1,249 @@
+import {makeTernDefs}from'../utils/tern-definitions.js';import {libraryManager}from'./library-manager.js';import {combineDefinitions,AUTOCOMPLETE_DEFINITIONS,getDefaultDefinitions,getLibraryDefinitions,getDefinition}from'./autocomplete/index.js';/**
+ * Autocomplete Manager for JavaScript Code Intelligence
+ * Integrates Tern definitions with library management for comprehensive autocomplete support
+ */
+/**
+ * Default autocomplete configuration
+ */
+const DEFAULT_CONFIG = {
+  includeDefaults: true,
+  includeLibraries: true,
+  enableDynamicLibraries: true,
+  customDefinitions: []
+};
+/**
+ * Manages autocomplete definitions and provides intelligent code completion
+ */
+class AutocompleteManager {
+  config;
+  cachedDefinitions = null;
+  lastUpdateTime = 0;
+  cacheTimeout = 5000; // 5 seconds
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    this.invalidateCache();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+  /**
+   * Invalidate the cached definitions
+   */
+  invalidateCache() {
+    this.cachedDefinitions = null;
+    this.lastUpdateTime = 0;
+  }
+  /**
+   * Get comprehensive autocomplete definitions
+   */
+  getDefinitions() {
+    const now = Date.now();
+    // Return cached definitions if still valid
+    if (this.cachedDefinitions && now - this.lastUpdateTime < this.cacheTimeout) {
+      return this.cachedDefinitions;
+    }
+    const definitions = [];
+    // Add default definitions (ECMAScript, Browser APIs)
+    if (this.config.includeDefaults) {
+      definitions.push(...getDefaultDefinitions());
+    }
+    // Add library definitions (lodash, base64-js, etc.)
+    if (this.config.includeLibraries) {
+      definitions.push(...getLibraryDefinitions());
+    }
+    // Add custom specified definitions
+    this.config.customDefinitions.forEach(defName => {
+      const definition = getDefinition(defName);
+      if (definition) {
+        definitions.push(definition);
+      }
+    });
+    // Add dynamic library definitions if enabled
+    if (this.config.enableDynamicLibraries) {
+      const dynamicDefs = this.getDynamicLibraryDefinitions();
+      if (dynamicDefs) {
+        definitions.push(dynamicDefs);
+      }
+    }
+    // Combine all definitions
+    this.cachedDefinitions = combineDefinitions(definitions);
+    this.lastUpdateTime = now;
+    return this.cachedDefinitions;
+  }
+  /**
+   * Get definitions for dynamically loaded libraries
+   */
+  getDynamicLibraryDefinitions() {
+    try {
+      const installedLibraries = libraryManager.getInstalledLibraries();
+      if (installedLibraries.length === 0) {
+        return null;
+      }
+      // Create definitions from installed library objects
+      const combinedDefs = {};
+      installedLibraries.forEach(libInfo => {
+        if (libInfo.global && typeof libInfo.global === 'object') {
+          // Generate Tern definitions from the library object
+          const ternDef = makeTernDefs(libInfo.global);
+          // Add to combined definitions under the library identifier
+          combinedDefs[libInfo.identifier] = ternDef;
+        }
+      });
+      if (Object.keys(combinedDefs).length === 0) {
+        return null;
+      }
+      return {
+        '!name': 'dynamic-libraries',
+        ...combinedDefs
+      };
+    } catch (error) {
+      console.warn('Failed to generate dynamic library definitions:', error);
+      return null;
+    }
+  }
+  /**
+   * Get Tern-compatible definition object
+   */
+  getTernDef() {
+    const definitions = this.getDefinitions();
+    return definitions;
+  }
+  /**
+   * Get available definition names
+   */
+  getAvailableDefinitions() {
+    return Object.keys(AUTOCOMPLETE_DEFINITIONS);
+  }
+  /**
+   * Check if a definition is available
+   */
+  hasDefinition(name) {
+    return name in AUTOCOMPLETE_DEFINITIONS;
+  }
+  /**
+   * Get completions for a specific context
+   */
+  getCompletions(context) {
+    return new Promise(resolve => {
+      try {
+        const definitions = this.getDefinitions();
+        const completions = [];
+        // Extract relevant completions from definitions
+        this.extractCompletions(definitions, context.scope || [], completions);
+        resolve({
+          completions: completions.slice(0, 100),
+          // Limit results
+          isIncomplete: completions.length > 100
+        });
+      } catch (error) {
+        console.error('Failed to get completions:', error);
+        resolve({
+          completions: [],
+          isIncomplete: false
+        });
+      }
+    });
+  }
+  /**
+   * Extract completions from definition object
+   */
+  extractCompletions(obj, scope, results, visited = new Set()) {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) {
+      return;
+    }
+    visited.add(obj);
+    const objRecord = obj;
+    Object.keys(objRecord).forEach(key => {
+      if (key.startsWith('!')) {
+        return; // Skip metadata
+      }
+      const value = objRecord[key];
+      if (typeof value === 'object' && value !== null) {
+        const valueRecord = value;
+        results.push({
+          name: key,
+          type: valueRecord['!type'] || 'unknown',
+          doc: valueRecord['!doc'],
+          url: valueRecord['!url']
+        });
+        // Recurse for nested properties
+        if (scope.length === 0 || scope.includes(key)) {
+          this.extractCompletions(value, scope.slice(1), results, visited);
+        }
+      } else {
+        results.push({
+          name: key,
+          type: typeof value
+        });
+      }
+    });
+    visited.delete(obj);
+  }
+  /**
+   * Get type information for a symbol
+   */
+  getTypeInfo(symbol, scope) {
+    try {
+      const definitions = this.getDefinitions();
+      return this.findSymbolInfo(definitions, symbol, scope || []);
+    } catch (error) {
+      console.error('Failed to get type info:', error);
+      return null;
+    }
+  }
+  /**
+   * Find symbol information in definitions
+   */
+  findSymbolInfo(obj, symbol, scope) {
+    if (!obj || typeof obj !== 'object') {
+      return null;
+    }
+    const objRecord = obj;
+    // Direct lookup
+    if (symbol in objRecord) {
+      const value = objRecord[symbol];
+      if (typeof value === 'object' && value !== null) {
+        const valueRecord = value;
+        return {
+          type: valueRecord['!type'],
+          doc: valueRecord['!doc'],
+          url: valueRecord['!url']
+        };
+      }
+    }
+    // Scoped lookup
+    if (scope.length > 0) {
+      const [currentScope, ...remainingScope] = scope;
+      if (currentScope in objRecord) {
+        return this.findSymbolInfo(objRecord[currentScope], symbol, remainingScope);
+      }
+    }
+    return null;
+  }
+  /**
+   * Refresh definitions (force cache invalidation and reload)
+   */
+  refresh() {
+    this.invalidateCache();
+    this.getDefinitions(); // Force reload
+  }
+}
+// Export a default instance
+const autocompleteManager = new AutocompleteManager();export{AutocompleteManager,autocompleteManager};//# sourceMappingURL=autocomplete-manager.js.map

package/lib/services/code/javascript/jslibrary/autocomplete-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete-manager.js","sources":["../../../../../src/services/code/javascript/jslibrary/autocomplete-manager.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}