@ticatec/dyna-js 0.0.3 → 0.1.0

package/dist/DynaJs.js

@@ -1,7 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("./utils");
+/**
+ * DynaJs - A safe dynamic code execution library
+ *
+ * Provides secure execution of dynamic JavaScript code using new Function()
+ * with configurable security policies and sandboxing capabilities.
+ *
+ * @example
+ * ```typescript
+ * const loader = new DynaJs({
+ *   defaultImports: { MyClass },
+ *   validateCode: true,
+ *   allowBrowserAPIs: false
+ * });
+ *
+ * const result = loader.executeSync(`return new MyClass()`);
+ * ```
+ */
 class DynaJs {
+    /**
+     * Creates a new DynaJs instance
+     *
+     * @param config - Configuration options for the DynaJs instance
+     * @param config.defaultTimeout - Default timeout for async execution in milliseconds (default: 5000)
+     * @param config.defaultStrict - Whether to use strict mode by default (default: true)
+     * @param config.allowedGlobals - Whitelist of allowed global variables (empty = allow all defaultImports)
+     * @param config.blockedGlobals - Blacklist of blocked global variables
+     * @param config.defaultImports - Pre-imported classes/functions available to dynamic code
+     * @param config.allowTimers - Allow setTimeout/setInterval in dynamic code (default: false)
+     * @param config.allowDynamicImports - Allow import()/require() in dynamic code (default: false)
+     * @param config.validateCode - Enable code validation before execution (default: true)
+     * @param config.allowBrowserAPIs - Allow access to browser APIs like window/document (default: false)
+     * @param config.allowNodeAPIs - Allow access to Node.js APIs like process/require (default: false)
+     */
     constructor(config = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         this.config = {
@@ -17,6 +49,18 @@ class DynaJs {
             allowNodeAPIs: (_k = config.allowNodeAPIs) !== null && _k !== void 0 ? _k : false
         };
     }
+    /**
+     * Asynchronously execute dynamic code with timeout support
+     *
+     * @template T - The expected return type of the executed code
+     * @param code - The JavaScript code to execute
+     * @param options - Execution options
+     * @param options.context - Additional context variables for the code
+     * @param options.timeout - Execution timeout in milliseconds (overrides defaultTimeout)
+     * @param options.strict - Whether to use strict mode (overrides defaultStrict)
+     * @param options.imports - Additional imports for this execution only
+     * @returns Promise resolving to the execution result
+     */
     async execute(code, options = {}) {
         var _a, _b;
         const startTime = performance.now();
@@ -31,17 +75,25 @@ class DynaJs {
             const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : this.config.defaultTimeout;
             const strict = (_b = options.strict) !== null && _b !== void 0 ? _b : this.config.defaultStrict;
             const result = await this.executeWithTimeout(code, context, timeout, strict);
-            const executionTime = performance.now() - startTime;
-            return {
-                result: result,
-                executionTime
-            };
+            console.info(`Build dyna code in ${performance.now() - startTime}ms`);
+            return result;
         }
         catch (error) {
             const executionTime = performance.now() - startTime;
             throw new Error(`Script execution failed after ${executionTime.toFixed(2)}ms: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Synchronously execute dynamic code and return result directly
+     *
+     * @template T - The expected return type of the executed code
+     * @param code - The JavaScript code to execute
+     * @param options - Execution options
+     * @param options.context - Additional context variables for the code
+     * @param options.strict - Whether to use strict mode (overrides defaultStrict)
+     * @param options.imports - Additional imports for this execution only
+     * @returns The direct result of code execution
+     */
     executeSync(code, options = {}) {
         var _a;
         const startTime = performance.now();
@@ -55,17 +107,26 @@ class DynaJs {
             const context = this.prepareContext(options.context, options.imports);
             const strict = (_a = options.strict) !== null && _a !== void 0 ? _a : this.config.defaultStrict;
             const result = this.executeCode(code, context, strict);
-            const executionTime = performance.now() - startTime;
-            return {
-                result: result,
-                executionTime
-            };
+            console.info(`Build dyna code in ${performance.now() - startTime}ms`);
+            return result;
         }
         catch (error) {
             const executionTime = performance.now() - startTime;
             throw new Error(`Script execution failed after ${executionTime.toFixed(2)}ms: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Execute code with a timeout constraint
+     *
+     * @private
+     * @template T - The expected return type
+     * @param code - The JavaScript code to execute
+     * @param context - Execution context with available variables
+     * @param timeout - Maximum execution time in milliseconds
+     * @param strict - Whether to use strict mode
+     * @returns Promise resolving to the execution result
+     * @throws {Error} If execution exceeds timeout or runtime error occurs
+     */
     async executeWithTimeout(code, context, timeout, strict) {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
@@ -82,6 +143,16 @@ class DynaJs {
             }
         });
     }
+    /**
+     * Core code execution engine using new Function()
+     *
+     * @private
+     * @param code - The JavaScript code to execute
+     * @param context - Execution context with available variables
+     * @param strict - Whether to use strict mode
+     * @returns The execution result
+     * @throws {Error} If code execution fails
+     */
     executeCode(code, context, strict) {
         const contextKeys = Object.keys(context);
         const contextValues = Object.values(context);
@@ -95,6 +166,29 @@ class DynaJs {
             throw new Error(`Code execution error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Create a reusable function from dynamic code
+     *
+     * @template T - The function signature type
+     * @param code - The JavaScript code for the function body
+     * @param paramNames - Array of parameter names for the function
+     * @param options - Execution options
+     * @param options.context - Additional context variables
+     * @param options.strict - Whether to use strict mode
+     * @param options.imports - Additional imports
+     * @returns A function that can be called multiple times
+     * @throws {Error} If function creation fails
+     *
+     * @example
+     * ```typescript
+     * const validator = loader.createFunction<(data: any) => boolean>(`
+     *   return function(data) {
+     *     return data.name && data.email;
+     *   };
+     * `);
+     * const isValid = validator({ name: 'John', email: 'john@example.com' });
+     * ```
+     */
     createFunction(code, paramNames = [], options = {}) {
         var _a;
         const context = this.prepareContext(options.context, options.imports);
@@ -115,27 +209,118 @@ class DynaJs {
             throw new Error(`Function creation error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Synchronously execute code with additional temporary imports
+     *
+     * @template T - The expected return type
+     * @param code - The JavaScript code to execute
+     * @param imports - Additional imports to merge with defaultImports
+     * @param options - Additional execution options
+     * @returns The direct result of code execution
+     * @throws {Error} If code validation fails or runtime error occurs
+     *
+     * @example
+     * ```typescript
+     * const result = loader.executeWithImports(`
+     *   return new CustomComponent();
+     * `, {
+     *   CustomComponent: MyCustomComponent
+     * });
+     * ```
+     */
     executeWithImports(code, imports, options = {}) {
         return this.executeSync(code, Object.assign(Object.assign({}, options), { imports: Object.assign(Object.assign({}, this.config.defaultImports), imports) }));
     }
+    /**
+     * Asynchronously execute code with additional temporary imports
+     *
+     * @template T - The expected return type
+     * @param code - The JavaScript code to execute
+     * @param imports - Additional imports to merge with defaultImports
+     * @param options - Additional execution options (including timeout)
+     * @returns Promise resolving to the execution result
+     * @throws {Error} If code validation fails, execution times out, or runtime error occurs
+     *
+     * @example
+     * ```typescript
+     * const result = await loader.executeWithImportsAsync(`
+     *   return await fetchData();
+     * `, {
+     *   fetchData: myFetchFunction
+     * }, { timeout: 5000 });
+     * ```
+     */
     async executeWithImportsAsync(code, imports, options = {}) {
         return this.execute(code, Object.assign(Object.assign({}, options), { imports: Object.assign(Object.assign({}, this.config.defaultImports), imports) }));
     }
+    /**
+     * Initialize the singleton instance of DynaJs
+     *
+     * @param config - Configuration options for the singleton instance
+     * @returns The initialized singleton instance
+     *
+     * @example
+     * ```typescript
+     * DynaJs.initialize({
+     *   defaultImports: { MyClass, MyFunction },
+     *   validateCode: true
+     * });
+     * ```
+     */
     static initialize(config) {
         if (DynaJs.instance == null) {
             DynaJs.instance = new DynaJs(config);
         }
         return DynaJs.instance;
     }
+    /**
+     * Get the singleton instance of DynaJs
+     *
+     * @returns The singleton instance
+     * @throws {Error} If DynaJs hasn't been initialized
+     *
+     * @example
+     * ```typescript
+     * const loader = DynaJs.getInstance();
+     * const result = loader.executeSync(`return 1 + 1`);
+     * ```
+     */
     static getInstance() {
         if (DynaJs.instance == null) {
             throw new Error("DynaJs hasn't been initialized. Call DynaJs.initialize() first.");
         }
         return DynaJs.instance;
     }
+    /**
+     * Reset the singleton instance (useful for testing)
+     *
+     * @example
+     * ```typescript
+     * DynaJs.reset();
+     * DynaJs.initialize(newConfig);
+     * ```
+     */
     static reset() {
         DynaJs.instance = null;
     }
+    /**
+     * Prepare the execution context by merging user context, imports, and applying security filters
+     *
+     * Execution flow:
+     * 1. Create safe context (filtering browser/node APIs based on config)
+     * 2. Merge with defaultImports and additional imports
+     * 3. Apply allowedGlobals whitelist filter if configured
+     *
+     * @private
+     * @param userContext - User-provided context variables
+     * @param imports - Additional imports for this execution
+     * @returns The final execution context
+     *
+     * @remarks
+     * If allowedGlobals is set and not empty, only variables in the whitelist will be available.
+     * This happens AFTER merging defaultImports, so make sure to include all needed imports
+     * in the allowedGlobals array if you use this feature.
+     */
     prepareContext(userContext = {}, imports = {}) {
         let context = (0, utils_1.createSafeContext)(userContext, {
             allowBrowserAPIs: this.config.allowBrowserAPIs,
@@ -155,5 +340,9 @@ class DynaJs {
         return context;
     }
 }
+/**
+ * Singleton instance of DynaJs
+ * @private
+ */
 DynaJs.instance = null;
 exports.default = DynaJs;

package/dist/ModuleLoader.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Function type for checking if a module needs to be updated
+ * @param data - Module data containing code and digest information
+ * @returns true if the module is up-to-date, false if it needs to be reloaded
+ */
+export type ModuleCheck = (data: any) => boolean;
+/**
+ * Function type for loading a module from remote source
+ * @param data - Module data containing information needed to load the module
+ * @returns Promise that resolves to the loaded module data
+ */
+export type LoadModule = (data: any) => Promise<any>;
+/**
+ * Function type for saving a module to local storage
+ * @param data - Module data to be saved
+ */
+export type SaveModuleToLocalStorage = (data: any) => void;
+/**
+ * Function type for loading a module from local storage
+ * @param data - Module identifier or data
+ * @returns The module script text
+ */
+export type LoadLocalModule = (data: any) => string;
+/**
+ * Configuration options for ModuleLoader
+ */
+export interface ModuleLoaderOptions {
+    /** Optional custom module check function */
+    moduleCheck?: ModuleCheck;
+    /** Optional custom save module function */
+    saveModule?: SaveModuleToLocalStorage;
+    /** Optional custom load local module function */
+    loadLocalModule?: LoadLocalModule;
+}
+/**
+ * ModuleLoader is a singleton class for managing dynamic module loading with caching
+ * It supports checking for module updates, loading from remote sources, and caching in localStorage
+ *
+ * @example
+ * ```typescript
+ * const loader = ModuleLoader.initialize(
+ *   async (data) => fetch(`/api/modules/${data.code}`).then(r => r.json()),
+ *   {}
+ * );
+ *
+ * await loader.checkFreshScripts([{ code: 'module1', digest: 'abc123' }]);
+ * const module = loader.createModule('module1', { React, ReactDOM });
+ * ```
+ */
+export default class ModuleLoader {
+    private static instance;
+    private readonly loadModule;
+    private readonly moduleCheck;
+    private readonly saveModule;
+    private readonly loadLocalModule;
+    private modulesMap;
+    /**
+     * Private constructor for singleton pattern
+     * @param loadModule - Function to load module from remote
+     * @param moduleCheck - Function to check module freshness
+     * @param saveModule - Function to save module locally
+     * @param loadLocalModule - Function to load module from local storage
+     */
+    private constructor();
+    /**
+     * Initialize the ModuleLoader singleton instance
+     * @param loadModule - Function to load module from remote source
+     * @param options - Configuration options with optional custom implementations
+     * @returns The singleton ModuleLoader instance
+     */
+    static initialize(loadModule: LoadModule, options: ModuleLoaderOptions): ModuleLoader;
+    /**
+     * Check and update modules that are not fresh
+     * Iterates through the list, checks each module, and reloads if needed
+     * Clears the module cache after checking all modules
+     *
+     * @param list - Array of module data objects to check
+     * @returns Promise that resolves when all modules are checked and updated
+     * ```
+     */
+    checkFreshScripts(list: Array<any>): Promise<void>;
+    /**
+     * Create or retrieve a cached module instance
+     * Loads the module script from local storage and executes it with provided imports
+     * Caches the result for subsequent calls
+     *
+     * @param key - The module key/code to load
+     * @param imports - Object containing dependencies to inject into the module
+     * @returns The instantiated module
+     */
+    createModule(key: string, imports: any): any;
+}
+//# sourceMappingURL=ModuleLoader.d.ts.map

package/dist/ModuleLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleLoader.d.ts","sourceRoot":"","sources":["../src/ModuleLoader.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC;AAEjD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,MAAM,CAAC;AA+BpD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,4CAA4C;IAC5C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,2CAA2C;IAC3C,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,iDAAiD;IACjD,eAAe,CAAC,EAAE,eAAe,CAAA;CACpC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2B;IACtD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,UAAU,CAAmB;IAErC;;;;;;OAMG;IACH,OAAO;IAQP;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY;IAQrF;;;;;;;;OAQG;IACG,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC;IAUxC;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,GAAG;CAU/C"}

package/dist/ModuleLoader.esm.js

@@ -0,0 +1,106 @@
+import { getDynaJs } from "./index";
+/**
+ * Default module check function that compares message digest
+ * @param data - Module data containing code and digest
+ * @returns true if the local digest matches the remote digest
+ */
+const checkMessageDigest = (data) => {
+    let localDigest = window.localStorage.getItem(`md:${data.code}`);
+    return localDigest == data.digest;
+};
+/**
+ * Default function to save module to localStorage
+ * Saves both the module digest and script text
+ * @param data - Module data containing code, digest, and scriptText
+ */
+const saveModule = (data) => {
+    window.localStorage.setItem(`md:${data.code}`, data.digest);
+    window.localStorage.setItem(`script:${data.code}`, data.scriptText);
+};
+/**
+ * Default function to load module script from localStorage
+ * @param key - Module key/code
+ * @returns The module script text
+ */
+const loadLocalModule = (key) => {
+    return window.localStorage.getItem(`script:${key}`);
+};
+/**
+ * ModuleLoader is a singleton class for managing dynamic module loading with caching
+ * It supports checking for module updates, loading from remote sources, and caching in localStorage
+ *
+ * @example
+ * ```typescript
+ * const loader = ModuleLoader.initialize(
+ *   async (data) => fetch(`/api/modules/${data.code}`).then(r => r.json()),
+ *   {}
+ * );
+ *
+ * await loader.checkFreshScripts([{ code: 'module1', digest: 'abc123' }]);
+ * const module = loader.createModule('module1', { React, ReactDOM });
+ * ```
+ */
+export default class ModuleLoader {
+    /**
+     * Private constructor for singleton pattern
+     * @param loadModule - Function to load module from remote
+     * @param moduleCheck - Function to check module freshness
+     * @param saveModule - Function to save module locally
+     * @param loadLocalModule - Function to load module from local storage
+     */
+    constructor(loadModule, moduleCheck, saveModule, loadLocalModule) {
+        this.loadModule = loadModule;
+        this.moduleCheck = moduleCheck;
+        this.saveModule = saveModule;
+        this.loadLocalModule = loadLocalModule;
+        this.modulesMap = new Map();
+    }
+    /**
+     * Initialize the ModuleLoader singleton instance
+     * @param loadModule - Function to load module from remote source
+     * @param options - Configuration options with optional custom implementations
+     * @returns The singleton ModuleLoader instance
+     */
+    static initialize(loadModule, options) {
+        if (ModuleLoader.instance == null) {
+            ModuleLoader.instance = new ModuleLoader(loadModule, options.moduleCheck ?? checkMessageDigest, options.saveModule ?? saveModule, options.loadLocalModule ?? loadLocalModule);
+        }
+        return ModuleLoader.instance;
+    }
+    /**
+     * Check and update modules that are not fresh
+     * Iterates through the list, checks each module, and reloads if needed
+     * Clears the module cache after checking all modules
+     *
+     * @param list - Array of module data objects to check
+     * @returns Promise that resolves when all modules are checked and updated
+     * ```
+     */
+    async checkFreshScripts(list) {
+        for (let item of list) {
+            if (!this.moduleCheck(item)) {
+                let data = await this.loadModule(item);
+                this.saveModule(data);
+            }
+        }
+        this.modulesMap.clear();
+    }
+    /**
+     * Create or retrieve a cached module instance
+     * Loads the module script from local storage and executes it with provided imports
+     * Caches the result for subsequent calls
+     *
+     * @param key - The module key/code to load
+     * @param imports - Object containing dependencies to inject into the module
+     * @returns The instantiated module
+     */
+    createModule(key, imports) {
+        let module = this.modulesMap.get(key);
+        if (module == null) {
+            let scriptText = this.loadLocalModule(key);
+            module = getDynaJs().executeSync(scriptText, { imports });
+            this.modulesMap.set(key, module);
+        }
+        return module;
+    }
+}

package/dist/ModuleLoader.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+/**
+ * Default module check function that compares message digest
+ * @param data - Module data containing code and digest
+ * @returns true if the local digest matches the remote digest
+ */
+const checkMessageDigest = (data) => {
+    let localDigest = window.localStorage.getItem(`md:${data.code}`);
+    return localDigest == data.digest;
+};
+/**
+ * Default function to save module to localStorage
+ * Saves both the module digest and script text
+ * @param data - Module data containing code, digest, and scriptText
+ */
+const saveModule = (data) => {
+    window.localStorage.setItem(`md:${data.code}`, data.digest);
+    window.localStorage.setItem(`script:${data.code}`, data.scriptText);
+};
+/**
+ * Default function to load module script from localStorage
+ * @param key - Module key/code
+ * @returns The module script text
+ */
+const loadLocalModule = (key) => {
+    return window.localStorage.getItem(`script:${key}`);
+};
+/**
+ * ModuleLoader is a singleton class for managing dynamic module loading with caching
+ * It supports checking for module updates, loading from remote sources, and caching in localStorage
+ *
+ * @example
+ * ```typescript
+ * const loader = ModuleLoader.initialize(
+ *   async (data) => fetch(`/api/modules/${data.code}`).then(r => r.json()),
+ *   {}
+ * );
+ *
+ * await loader.checkFreshScripts([{ code: 'module1', digest: 'abc123' }]);
+ * const module = loader.createModule('module1', { React, ReactDOM });
+ * ```
+ */
+class ModuleLoader {
+    /**
+     * Private constructor for singleton pattern
+     * @param loadModule - Function to load module from remote
+     * @param moduleCheck - Function to check module freshness
+     * @param saveModule - Function to save module locally
+     * @param loadLocalModule - Function to load module from local storage
+     */
+    constructor(loadModule, moduleCheck, saveModule, loadLocalModule) {
+        this.loadModule = loadModule;
+        this.moduleCheck = moduleCheck;
+        this.saveModule = saveModule;
+        this.loadLocalModule = loadLocalModule;
+        this.modulesMap = new Map();
+    }
+    /**
+     * Initialize the ModuleLoader singleton instance
+     * @param loadModule - Function to load module from remote source
+     * @param options - Configuration options with optional custom implementations
+     * @returns The singleton ModuleLoader instance
+     */
+    static initialize(loadModule, options) {
+        var _a, _b, _c;
+        if (ModuleLoader.instance == null) {
+            ModuleLoader.instance = new ModuleLoader(loadModule, (_a = options.moduleCheck) !== null && _a !== void 0 ? _a : checkMessageDigest, (_b = options.saveModule) !== null && _b !== void 0 ? _b : saveModule, (_c = options.loadLocalModule) !== null && _c !== void 0 ? _c : loadLocalModule);
+        }
+        return ModuleLoader.instance;
+    }
+    /**
+     * Check and update modules that are not fresh
+     * Iterates through the list, checks each module, and reloads if needed
+     * Clears the module cache after checking all modules
+     *
+     * @param list - Array of module data objects to check
+     * @returns Promise that resolves when all modules are checked and updated
+     * ```
+     */
+    async checkFreshScripts(list) {
+        for (let item of list) {
+            if (!this.moduleCheck(item)) {
+                let data = await this.loadModule(item);
+                this.saveModule(data);
+            }
+        }
+        this.modulesMap.clear();
+    }
+    /**
+     * Create or retrieve a cached module instance
+     * Loads the module script from local storage and executes it with provided imports
+     * Caches the result for subsequent calls
+     *
+     * @param key - The module key/code to load
+     * @param imports - Object containing dependencies to inject into the module
+     * @returns The instantiated module
+     */
+    createModule(key, imports) {
+        let module = this.modulesMap.get(key);
+        if (module == null) {
+            let scriptText = this.loadLocalModule(key);
+            module = (0, index_1.getDynaJs)().executeSync(scriptText, { imports });
+            this.modulesMap.set(key, module);
+        }
+        return module;
+    }
+}
+exports.default = ModuleLoader;

package/dist/types.d.ts

@@ -9,12 +9,6 @@ export interface ExecutionOptions {
     timeout?: number;
     strict?: boolean;
     imports?: ModuleImports;
-    injectedKeys?: string[];
-    useProxy?: boolean;
-}
-export interface ExecutionResult<T = any> {
-    result: T;
-    executionTime: number;
 }
 export interface DynaJsConfig {
     defaultTimeout?: number;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,GAAG;IACtC,MAAM,EAAE,CAAC,CAAC;IACV,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ticatec/dyna-js",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "A TypeScript library for dynamic code execution using new Function() that works in both Node.js and browser environments",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -41,8 +41,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ticatec/DynaJS.git",
-    "directory": "dynamic-script-loader"
+    "url": "git+https://github.com/ticatec/DynaJS.git"
   },
   "bugs": {
     "url": "https://github.com/ticatec/DynaJS/issues"