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

package/lib/services/code/javascript/jslibrary/definitions.d.ts

@@ -0,0 +1,465 @@
+/**
+ * Predefined Tern definitions for JavaScript libraries and built-in objects
+ */
+export declare const TERN_DEFINITIONS: {
+    readonly 'base64-js': {
+        readonly '!name': "base64-js";
+        readonly btoa: {
+            readonly '!doc': "creates a base-64 encoded ASCII string from a \"string\" of binary data";
+            readonly '!type': "fn(aString: string) -> string";
+        };
+        readonly atob: {
+            readonly '!doc': "decodes a base64 encoded string";
+            readonly '!type': "fn(bString: string) -> string";
+        };
+    };
+    readonly browser: {
+        readonly '!name': "browser";
+        readonly console: {
+            readonly assert: {
+                readonly '!type': "fn(assertion: bool, text: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.assert";
+                readonly '!doc': "Writes an error message to the console if the assertion is false.";
+            };
+            readonly clear: {
+                readonly '!type': "fn()";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/API/Console/clear";
+                readonly '!doc': "Clear the console.";
+            };
+            readonly count: {
+                readonly '!type': "fn(label?: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.count";
+                readonly '!doc': "Logs the number of times that this particular call to count() has been called.";
+            };
+            readonly debug: "console.log";
+            readonly dir: {
+                readonly '!type': "fn(object: ?)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.dir";
+                readonly '!doc': "Displays an interactive list of the properties of the specified JavaScript object.";
+            };
+            readonly error: {
+                readonly '!type': "fn(...msg: ?)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/DOM/console.error";
+                readonly '!doc': "Outputs an error message to the Web Console.";
+            };
+            readonly group: {
+                readonly '!type': "fn(label?: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.group";
+                readonly '!doc': "Creates a new inline group in the Web Console log.";
+            };
+            readonly groupCollapsed: {
+                readonly '!type': "fn(label?: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.groupCollapsed";
+                readonly '!doc': "Creates a new inline group in the Web Console log.";
+            };
+            readonly groupEnd: {
+                readonly '!type': "fn()";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.groupEnd";
+                readonly '!doc': "Exits the current inline group in the Web Console.";
+            };
+            readonly info: {
+                readonly '!type': "fn(...msg: ?)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/DOM/console.info";
+                readonly '!doc': "Outputs an informational message to the Web Console.";
+            };
+            readonly log: {
+                readonly '!type': "fn(...msg: ?)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/DOM/console.log";
+                readonly '!doc': "Outputs a message to the Web Console.";
+            };
+            readonly table: {
+                readonly '!type': "fn(data: []|?, columns?: [])";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/API/Console/table";
+                readonly '!doc': "Displays tabular data as a table.";
+            };
+            readonly time: {
+                readonly '!type': "fn(label: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.time";
+                readonly '!doc': "Starts a timer you can use to track how long an operation takes.";
+            };
+            readonly timeEnd: {
+                readonly '!type': "fn(label: string)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.timeEnd";
+                readonly '!doc': "Stops a timer that was previously started by calling console.time().";
+            };
+            readonly trace: {
+                readonly '!type': "fn()";
+                readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console.trace";
+                readonly '!doc': "Outputs a stack trace to the Web Console.";
+            };
+            readonly warn: {
+                readonly '!type': "fn(...msg: ?)";
+                readonly '!url': "https://developer.mozilla.org/en/docs/DOM/console.warn";
+                readonly '!doc': "Outputs a warning message to the Web Console.";
+            };
+            readonly '!url': "https://developer.mozilla.org/en/docs/Web/API/Console";
+            readonly '!doc': "The console object provides access to the browser's debugging console.";
+        };
+        readonly crypto: {
+            readonly getRandomValues: {
+                readonly '!type': "fn([number])";
+                readonly '!url': "https://developer.mozilla.org/en/docs/DOM/window.crypto.getRandomValues";
+                readonly '!doc': "This methods lets you get cryptographically random values.";
+            };
+            readonly '!url': "https://developer.mozilla.org/en/docs/DOM/window.crypto.getRandomValues";
+            readonly '!doc': "This methods lets you get cryptographically random values.";
+        };
+        readonly Blob: {
+            readonly '!type': "fn(parts: [?], options?: ?)";
+            readonly prototype: {
+                readonly size: {
+                    readonly '!type': "number";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/API/Blob/size";
+                    readonly '!doc': "The size, in bytes, of the data contained in the Blob object. Read only.";
+                };
+                readonly type: {
+                    readonly '!type': "string";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/API/Blob/type";
+                    readonly '!doc': "An ASCII-encoded string indicating the MIME type of the data contained in the Blob.";
+                };
+                readonly slice: {
+                    readonly '!type': "fn(start: number, end?: number, type?: string) -> +Blob";
+                    readonly '!url': "https://developer.mozilla.org/en/docs/DOM/Blob";
+                    readonly '!doc': "Returns a new Blob object containing the data in the specified range of bytes.";
+                };
+            };
+            readonly '!url': "https://developer.mozilla.org/en/docs/DOM/Blob";
+            readonly '!doc': "A Blob object represents a file-like object of immutable, raw data.";
+        };
+        readonly setTimeout: {
+            readonly '!type': "fn(f: fn(), ms: number) -> number";
+            readonly '!url': "https://developer.mozilla.org/en/docs/DOM/window.setTimeout";
+            readonly '!doc': "Calls a function or executes a code snippet after specified delay.";
+        };
+        readonly clearTimeout: {
+            readonly '!type': "fn(timerId: number)";
+            readonly '!url': "https://developer.mozilla.org/en/docs/DOM/window.clearTimeout";
+            readonly '!doc': "Clears the function scheduled to run by setTimeout().";
+        };
+        readonly fetch: {
+            readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API";
+            readonly '!doc': "The Fetch API provides an interface for fetching resources (including across the network).";
+            readonly '!type': "fn(url: string, options?: ?) -> +Promise[:t=+Response]";
+        };
+        readonly URL: {
+            readonly '!type': "fn(url: string, base?: string)";
+            readonly createObjectURL: {
+                readonly '!type': "fn(object: +Blob|+File): string";
+            };
+            readonly canParse: {
+                readonly '!type': "fn(url: string, base?: string): bool";
+            };
+            readonly revokeObjectURL: {
+                readonly '!type': "fn(url: string): void";
+            };
+            readonly prototype: {
+                readonly hash: {
+                    readonly '!type': "string";
+                };
+                readonly host: {
+                    readonly '!type': "string";
+                };
+                readonly hostname: {
+                    readonly '!type': "string";
+                };
+                readonly href: {
+                    readonly '!type': "string";
+                };
+                readonly origin: {
+                    readonly '!type': "string";
+                };
+                readonly pathname: {
+                    readonly '!type': "string";
+                };
+                readonly port: {
+                    readonly '!type': "string";
+                };
+                readonly protocol: {
+                    readonly '!type': "string";
+                };
+                readonly search: {
+                    readonly '!type': "string";
+                };
+                readonly toString: {
+                    readonly '!type': "fn() -> string";
+                };
+                readonly toJSON: {
+                    readonly '!type': "fn() -> string";
+                };
+            };
+        };
+    };
+    readonly ecmascript: {
+        readonly '!name': "ecmascript";
+        readonly '!define': {
+            readonly 'Error.prototype': "Error.prototype";
+            readonly propertyDescriptor: {
+                readonly enumerable: "bool";
+                readonly configurable: "bool";
+                readonly value: "?";
+                readonly writable: "bool";
+                readonly get: "fn() -> ?";
+                readonly set: "fn(value: ?)";
+            };
+            readonly 'Promise.prototype': {
+                readonly catch: {
+                    readonly '!doc': "The catch() method returns a Promise and deals with rejected cases only.";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch";
+                    readonly '!type': "fn(onRejected: fn(reason: ?)) -> !this";
+                };
+                readonly then: {
+                    readonly '!doc': "The then() method returns a Promise.";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then";
+                    readonly '!type': "fn(onFulfilled: fn(value: ?), onRejected: fn(reason: ?)) -> !custom:Promise_then";
+                    readonly '!effects': readonly ["call !0 !this.:t"];
+                };
+            };
+        };
+        readonly Object: {
+            readonly '!type': "fn()";
+            readonly getPrototypeOf: {
+                readonly '!type': "fn(obj: ?) -> ?";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/getPrototypeOf";
+                readonly '!doc': "Returns the prototype (i.e. the internal prototype) of the specified object.";
+            };
+            readonly create: {
+                readonly '!type': "fn(proto: ?) -> !custom:Object_create";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/create";
+                readonly '!doc': "Creates a new object with the specified prototype object and properties.";
+            };
+            readonly keys: {
+                readonly '!type': "fn(obj: ?) -> [string]";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys";
+                readonly '!doc': "Returns an array of a given object's own enumerable properties.";
+            };
+            readonly assign: {
+                readonly '!type': "fn(target: ?, source: ?, source?: ?) -> !0";
+                readonly '!effects': readonly ["copy !1 !0", "copy !2 !0", "copy !3 !0"];
+                readonly '!doc': "The Object.assign() method is used to copy the values of all enumerable own properties.";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign";
+            };
+        };
+        readonly Array: {
+            readonly '!type': "fn(size: number) -> !custom:Array_ctor";
+            readonly isArray: {
+                readonly '!type': "fn(value: ?) -> bool";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray";
+                readonly '!doc': "Returns true if an object is an array, false if it is not.";
+            };
+            readonly from: {
+                readonly '!type': "fn(arrayLike: ?, mapFn?: fn(elt: ?, i: number) -> ?, thisArg?: ?) -> [!0.<i>]";
+                readonly '!effects': readonly ["call !1 this=!2 !0.<i> number"];
+                readonly '!doc': "The Array.from() method creates a new Array instance from an array-like or iterable object.";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from";
+            };
+            readonly prototype: {
+                readonly '!stdProto': "Array";
+                readonly length: {
+                    readonly '!type': "number";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/length";
+                    readonly '!doc': "An unsigned, 32-bit integer that specifies the number of elements in an array.";
+                };
+                readonly push: {
+                    readonly '!type': "fn(newelt: ?) -> number";
+                    readonly '!effects': readonly ["propagate !0 !this.<i>"];
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/push";
+                    readonly '!doc': "Mutates an array by appending the given elements and returning the new length.";
+                };
+                readonly pop: {
+                    readonly '!type': "fn() -> !this.<i>";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/pop";
+                    readonly '!doc': "Removes the last element from an array and returns that element.";
+                };
+                readonly map: {
+                    readonly '!type': "fn(f: fn(elt: ?, i: number, array: +Array) -> ?, context?: ?) -> [!0.!ret]";
+                    readonly '!effects': readonly ["call !0 this=!1 !this.<i> number !this"];
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map";
+                    readonly '!doc': "Creates a new array with the results of calling a provided function on every element.";
+                };
+                readonly filter: {
+                    readonly '!type': "fn(test: fn(elt: ?, i: number, array: +Array) -> bool, context?: ?) -> !this";
+                    readonly '!effects': readonly ["call !0 this=!1 !this.<i> number !this"];
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/filter";
+                    readonly '!doc': "Creates a new array with all elements that pass the test implemented by the provided function.";
+                };
+                readonly forEach: {
+                    readonly '!type': "fn(f: fn(elt: ?, i: number, array: +Array), context?: ?)";
+                    readonly '!effects': readonly ["call !0 this=!1 !this.<i> number !this"];
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/forEach";
+                    readonly '!doc': "Executes a provided function once per array element.";
+                };
+            };
+        };
+        readonly String: {
+            readonly '!type': "fn(value: ?) -> string";
+            readonly prototype: {
+                readonly '!stdProto': "String";
+                readonly length: {
+                    readonly '!type': "number";
+                    readonly '!url': "https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/String/length";
+                    readonly '!doc': "Represents the length of a string.";
+                };
+                readonly charAt: {
+                    readonly '!type': "fn(i: number) -> string";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/charAt";
+                    readonly '!doc': "Returns the specified character from a string.";
+                };
+                readonly indexOf: {
+                    readonly '!type': "fn(char: string, from?: number) -> number";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/indexOf";
+                    readonly '!doc': "Returns the index within the calling String object of the first occurrence of the specified value.";
+                };
+                readonly substring: {
+                    readonly '!type': "fn(from: number, to?: number) -> string";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/substring";
+                    readonly '!doc': "Returns a subset of a string between one index and another.";
+                };
+                readonly split: {
+                    readonly '!type': "fn(pattern?: string|+RegExp, limit?: number) -> [string]";
+                    readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/split";
+                    readonly '!doc': "Splits a String object into an array of strings by separating the string into substrings.";
+                };
+            };
+        };
+        readonly Math: {
+            readonly PI: {
+                readonly '!type': "number";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/PI";
+                readonly '!doc': "The ratio of the circumference of a circle to its diameter, approximately 3.14159.";
+            };
+            readonly abs: {
+                readonly '!type': "fn(number) -> number";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/abs";
+                readonly '!doc': "Returns the absolute value of a number.";
+            };
+            readonly floor: {
+                readonly '!type': "fn(number) -> number";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/floor";
+                readonly '!doc': "Returns the largest integer less than or equal to a number.";
+            };
+            readonly random: {
+                readonly '!type': "fn() -> number";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/random";
+                readonly '!doc': "Returns a floating-point, pseudo-random number in the range [0, 1).";
+            };
+        };
+        readonly JSON: {
+            readonly parse: {
+                readonly '!type': "fn(json: string, reviver?: fn(key: string, value: ?) -> ?) -> ?";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/JSON/parse";
+                readonly '!doc': "Parse a string as JSON, optionally transforming the value produced by parsing.";
+            };
+            readonly stringify: {
+                readonly '!type': "fn(value: ?, replacer?: fn(key: string, value: ?) -> ?, space?: string|number) -> string";
+                readonly '!url': "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/JSON/stringify";
+                readonly '!doc': "Convert a value to JSON.";
+            };
+        };
+    };
+    readonly lodash: {
+        readonly '!name': "LIB/lodash";
+        readonly _: {
+            readonly chunk: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#chunk";
+                readonly '!doc': "Creates an array of elements split into groups the length of size.";
+                readonly '!type': "fn(array, [size])";
+            };
+            readonly compact: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#compact";
+                readonly '!doc': "Creates an array with all falsey values removed.";
+                readonly '!type': "fn(array)";
+            };
+            readonly map: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#map";
+                readonly '!doc': "Creates an array of values by running each element in collection thru iteratee.";
+                readonly '!type': "fn(collection, [iteratee])";
+            };
+            readonly filter: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#filter";
+                readonly '!doc': "Iterates over elements of collection, returning an array of all elements predicate returns truthy for.";
+                readonly '!type': "fn(collection, [predicate])";
+            };
+            readonly find: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#find";
+                readonly '!doc': "Iterates over elements of collection, returning the first element predicate returns truthy for.";
+                readonly '!type': "fn(collection, [predicate], [fromIndex])";
+            };
+            readonly forEach: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#forEach";
+                readonly '!doc': "Iterates over elements of collection and invokes iteratee for each element.";
+                readonly '!type': "fn(collection, [iteratee])";
+            };
+            readonly reduce: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#reduce";
+                readonly '!doc': "Reduces collection to a value which is the accumulated result of running each element in collection thru iteratee.";
+                readonly '!type': "fn(collection, [iteratee], [accumulator])";
+            };
+            readonly clone: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#clone";
+                readonly '!doc': "Creates a shallow clone of value.";
+                readonly '!type': "fn(value)";
+            };
+            readonly cloneDeep: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#cloneDeep";
+                readonly '!doc': "This method is like _.clone except that it recursively clones value.";
+                readonly '!type': "fn(value)";
+            };
+            readonly isArray: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#isArray";
+                readonly '!doc': "Checks if value is classified as an Array object.";
+                readonly '!type': "fn(value)";
+            };
+            readonly isObject: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#isObject";
+                readonly '!doc': "Checks if value is the language type of Object.";
+                readonly '!type': "fn(value)";
+            };
+            readonly isString: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#isString";
+                readonly '!doc': "Checks if value is classified as a String primitive or object.";
+                readonly '!type': "fn(value)";
+            };
+            readonly get: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#get";
+                readonly '!doc': "Gets the value at path of object.";
+                readonly '!type': "fn(object, path, [defaultValue])";
+            };
+            readonly set: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#set";
+                readonly '!doc': "Sets the value at path of object.";
+                readonly '!type': "fn(object, path, value)";
+            };
+            readonly merge: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#merge";
+                readonly '!doc': "This method is like _.assign except that it recursively merges own and inherited enumerable string keyed properties.";
+                readonly '!type': "fn(object, [sources])";
+            };
+            readonly pick: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#pick";
+                readonly '!doc': "Creates an object composed of the picked object properties.";
+                readonly '!type': "fn(object, [paths])";
+            };
+            readonly omit: {
+                readonly '!url': "https://lodash.com/docs/4.17.15#omit";
+                readonly '!doc': "The opposite of _.pick; this method creates an object composed of the own and inherited enumerable property paths of object that are not omitted.";
+                readonly '!type': "fn(object, [paths])";
+            };
+        };
+    };
+};
+/**
+ * Get Tern definition for a specific library
+ */
+export declare function getTernDefinition(libraryName: string): Record<string, any> | null;
+/**
+ * Get all available library names
+ */
+export declare function getAvailableLibraries(): string[];
+/**
+ * Combine multiple Tern definitions
+ */
+export declare function combineTernDefinitions(...definitions: Record<string, any>[]): Record<string, any>;
+/**
+ * Create a complete Tern server configuration with the specified libraries
+ */
+export declare function createTernConfig(libraries?: string[]): any;

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

@@ -0,0 +1,4 @@
+import { JSLibrary } from '../utils/types';
+export declare const defaultLibraries: JSLibrary[];
+export declare const JSLibraries: JSLibrary[];
+export declare const libraryReservedIdentifiers: Record<string, boolean>;

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

@@ -0,0 +1,14 @@
+// Default libraries
+const defaultLibraries = [{
+  accessor: ['_'],
+  version: '4.17.21',
+  docsURL: 'https://lodash.com/docs/4.17.21',
+  name: 'lodash'
+}];
+const JSLibraries = [...defaultLibraries];
+const libraryReservedIdentifiers = defaultLibraries.reduce((acc, lib) => {
+  lib.accessor.forEach(a => {
+    acc[a] = true;
+  });
+  return acc;
+}, {});export{JSLibraries,defaultLibraries,libraryReservedIdentifiers};//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/services/code/javascript/jslibrary/index.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;AACO,MAAM,gBAAgB,GAAgB,CAAA;AACzC,EAAA,QAAA,EAAA,CAAA,GAAA,CAAA;SACI,EAAA,SAAW;AACX,EAAA,OAAA,EAAA,iCAAkB;AAClB,EAAA,IAAA,EAAA;AACA,CAAA;AACH,MAAA,WAAA,GAAA,CAAA,GAAA,gBAAA;AACH,MAAA,0BAAA,GAAA,gBAAA,CAAA,MAAA,CAAA,CAAA,GAAA,EAAA,GAAA,KAAA;AAEF,EAAA,GAAA,CAAM,QAAO,CAAA,OAAA,CAAA,CAAW,IAAI;AAE5B,IAAA,GAAO,CAAA,CAAA,CAAA,GAAM,IAAA;IACT;AACI,EAAA,OAAA,GAAI;AACR,CAAA,EAAA,EAAC"}

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

@@ -0,0 +1,53 @@
+/**
+ * Library Manager for JavaScript Runtime Libraries
+ * Manages installed libraries and their global objects
+ */
+import { JSLibrary } from '../utils/types';
+/**
+ * Information about an installed library
+ */
+export interface InstalledLibraryInfo {
+    identifier: string;
+    library: JSLibrary;
+    global: unknown;
+    installTime: number;
+}
+/**
+ * Manages JavaScript libraries and their runtime objects
+ */
+export declare class LibraryManager {
+    private installedLibraries;
+    /**
+     * Install a library with its global object
+     */
+    installLibrary(identifier: string, library: JSLibrary, global: unknown): void;
+    /**
+     * Uninstall a library
+     */
+    uninstallLibrary(identifier: string): boolean;
+    /**
+     * Get installed library information
+     */
+    getInstalledLibrary(identifier: string): InstalledLibraryInfo | undefined;
+    /**
+     * Get all installed libraries
+     */
+    getInstalledLibraries(): InstalledLibraryInfo[];
+    /**
+     * Check if a library is installed
+     */
+    isLibraryInstalled(identifier: string): boolean;
+    /**
+     * Get available libraries (from the default set)
+     */
+    getAvailableLibraries(): JSLibrary[];
+    /**
+     * Clear all installed libraries
+     */
+    clearAll(): void;
+    /**
+     * Get library count
+     */
+    getLibraryCount(): number;
+}
+export declare const libraryManager: LibraryManager;

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

@@ -0,0 +1,65 @@
+import {JSLibraries}from'./index.js';/**
+ * Library Manager for JavaScript Runtime Libraries
+ * Manages installed libraries and their global objects
+ */
+/**
+ * Manages JavaScript libraries and their runtime objects
+ */
+class LibraryManager {
+  installedLibraries = new Map();
+  /**
+   * Install a library with its global object
+   */
+  installLibrary(identifier, library, global) {
+    this.installedLibraries.set(identifier, {
+      identifier,
+      library,
+      global,
+      installTime: Date.now()
+    });
+  }
+  /**
+   * Uninstall a library
+   */
+  uninstallLibrary(identifier) {
+    return this.installedLibraries.delete(identifier);
+  }
+  /**
+   * Get installed library information
+   */
+  getInstalledLibrary(identifier) {
+    return this.installedLibraries.get(identifier);
+  }
+  /**
+   * Get all installed libraries
+   */
+  getInstalledLibraries() {
+    return Array.from(this.installedLibraries.values());
+  }
+  /**
+   * Check if a library is installed
+   */
+  isLibraryInstalled(identifier) {
+    return this.installedLibraries.has(identifier);
+  }
+  /**
+   * Get available libraries (from the default set)
+   */
+  getAvailableLibraries() {
+    return [...JSLibraries];
+  }
+  /**
+   * Clear all installed libraries
+   */
+  clearAll() {
+    this.installedLibraries.clear();
+  }
+  /**
+   * Get library count
+   */
+  getLibraryCount() {
+    return this.installedLibraries.size;
+  }
+}
+// Export singleton instance
+const libraryManager = new LibraryManager();export{LibraryManager,libraryManager};//# sourceMappingURL=library-manager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"library-manager.js","sources":["../../../../../src/services/code/javascript/jslibrary/library-manager.ts"],"sourcesContent":[null],"names":[],"mappings":"qCAAA;;;AAGG;AAeH;;AAEG;MACU,cAAc,CAAA;AACf,EAAA,kBAAA,GAAkB,IAAG,GAAI,EAAG;AAEpC;;AAEG;AACH,EAAA,cAAA,CAAA,UAAe,EAAkB,OAAE,EAAkB,MAAE,EAAe;AAClE,IAAA,IAAA,CAAA,kBAAK,CAAA,GAAkB,CAAC;gBACpB;aACA;YACA;AACA,MAAA,WAAA,EAAA,IAAW,CAAA,GAAE;AAChB,KAAA,CAAA;;AAGL;;AAEG;AACH,EAAA,gBAAA,CAAA,UAAiB,EAAkB;WAC/B,IAAO,CAAA,kBAAK,CAAA,iBAA0B,CAAA;;AAG1C;;AAEG;AACH,EAAA,mBAAA,CAAA,UAAoB,EAAkB;WAClC,IAAO,CAAA,kBAAK,CAAA,GAAkB,CAAC,UAAI,CAAA;;AAGvC;;AAEG;uBACH,GAAqB;WACjB,KAAO,CAAA,IAAM,CAAA,IAAK,CAAA,kBAAK,CAAA,MAAmB,EAAA,CAAA;;AAG9C;;AAEG;AACH,EAAA,kBAAA,CAAA,UAAmB,EAAkB;WACjC,IAAO,CAAA,kBAAK,CAAA,GAAkB,CAAC,UAAI,CAAA;;AAGvC;;AAEG;uBACH,GAAqB;AACjB,IAAA,OAAA,CAAA,GAAO,WAAI,CAAA;;AAGf;;AAEG;UACH,GAAQ;AACJ,IAAA,IAAA,CAAA,kBAAK,CAAA,KAAmB,EAAA;;AAG5B;;AAEG;iBACH,GAAe;AACX,IAAA,OAAA,IAAO,CAAA,kBAAK,CAAA,IAAmB;;AAEtC;AAED;AACO,MAAM,cAAc,GAAG,IAAI,cAAc"}

package/lib/services/code/javascript/jslibrary/reset.d.ts

@@ -0,0 +1,2 @@
+export declare const invalidEntityIdentifiers: Record<string, unknown>;
+export declare function resetJSLibraries(): void;

package/lib/services/code/javascript/jslibrary/reset.js

@@ -0,0 +1,33 @@
+import*as lodash from'lodash-es';import {libraryReservedIdentifiers,JSLibraries,defaultLibraries}from'./index.js';const defaultLibImplementations = {
+  lodash
+  // We are removing some functionalities of node-forge because they wont
+  // work in the worker thread
+  // forge: /*#__PURE*/ _.omit(forge, ["tls", "http", "xhr", "socket", "task"]),
+};
+// Invalid Entity Identifiers for dependency management
+const invalidEntityIdentifiers = {
+  ...libraryReservedIdentifiers
+};
+function resetJSLibraries() {
+  JSLibraries.length = 0;
+  JSLibraries.push(...defaultLibraries);
+  const defaultLibraryAccessors = defaultLibraries.map(lib => lib.accessor[0]);
+  for (const key of Object.keys(libraryReservedIdentifiers)) {
+    if (defaultLibraryAccessors.includes(key)) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    try {
+      delete globalThis[key];
+    } catch (e) {
+      globalThis[key] = undefined;
+    }
+    // We have to update invalidEntityIdentifiers as well
+    delete libraryReservedIdentifiers[key];
+    delete invalidEntityIdentifiers[key];
+  }
+  JSLibraries.forEach(library => {
+    if (!(library.name in defaultLibImplementations)) throw new Error(`resetJSLibraries(): implementation for library ${library.name} not found. Have you forgotten to add it to the defaultLibrariesImpls object?`);
+    globalThis[library.accessor[0]] = defaultLibImplementations[library.name];
+  });
+}export{invalidEntityIdentifiers,resetJSLibraries};//# sourceMappingURL=reset.js.map