@ticatec/dyna-js 0.0.4 → 0.1.0

package/README.md

@@ -11,13 +11,13 @@ A TypeScript library for safe dynamic code execution using `new Function()` that
 
 ## Features
 
-✅ **Universal Compatibility** - Works in both Node.js and browser environments
-✅ **TypeScript Support** - Full type safety with comprehensive type definitions
-✅ **Singleton Pattern** - Initialize once, use anywhere
-✅ **Module Imports** - Pre-define classes and functions for dynamic code
-✅ **Configurable Security** - Fine-grained control over allowed APIs and operations
-✅ **Multiple Build Formats** - CommonJS and ESM support
-✅ **Performance Monitoring** - Built-in execution time tracking  
+✅ **Universal Compatibility** - Works in both Node.js and browser environments  
+✅ **TypeScript Support** - Full type safety with comprehensive type definitions  
+✅ **Singleton Pattern** - Initialize once, use anywhere  
+✅ **Module Imports** - Pre-define classes and functions for dynamic code  
+✅ **Configurable Security** - Fine-grained control over allowed APIs and operations  
+✅ **Multiple Build Formats** - CommonJS and ESM support  
+✅ **Performance Monitoring** - Built-in execution time tracking    
 
 ## Installation
 
@@ -298,6 +298,206 @@ const validation = dynamicValidator({
 });
 ```
 
+## ModuleLoader - Dynamic Module Management
+
+`ModuleLoader` is a singleton class for managing dynamic JavaScript modules with automatic caching and version control. It's perfect for loading remote code modules and managing their lifecycle.
+
+### Key Features
+
+- **Singleton Pattern** - Single instance manages all modules
+- **Version Control** - Automatic digest-based freshness checking
+- **Local Caching** - Stores modules in localStorage for offline access
+- **Lazy Loading** - Modules are only instantiated when needed
+- **Custom Hooks** - Override default behaviors with custom implementations
+
+### Basic Usage
+
+#### 1. Initialize the ModuleLoader
+
+```typescript
+import { ModuleLoader } from '@ticatec/dyna-js';
+
+// Define how to load modules from your server
+const loadModuleFromServer = async (moduleInfo) => {
+  const response = await fetch(`/api/modules/${moduleInfo.code}`);
+  return response.json(); // Should return { code, digest, scriptText }
+};
+
+// Initialize the singleton
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // All options are optional - defaults use localStorage
+});
+```
+
+#### 2. Check and Update Modules
+
+```typescript
+// Check a list of modules and update if needed
+await moduleLoader.checkFreshScripts([
+  { code: 'user-form', digest: 'abc123...' },
+  { code: 'data-grid', digest: 'def456...' },
+  { code: 'chart-widget', digest: 'ghi789...' }
+]);
+
+// This will:
+// 1. Check each module's digest against localStorage
+// 2. Download and save modules that have changed
+// 3. Clear the module instance cache
+```
+
+#### 3. Create and Use Modules
+
+```typescript
+// Import dependencies that the module needs
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+// Create the module instance
+const UserForm = moduleLoader.createModule('user-form', {
+  React,
+  ReactDOM,
+  // Add any other dependencies your module needs
+});
+
+// Use the module (it's now cached for subsequent calls)
+const formInstance = new UserForm({
+  title: 'User Registration',
+  onSubmit: handleSubmit
+});
+```
+
+### Advanced Configuration
+
+#### Custom Module Check Function
+
+```typescript
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // Custom logic to check if module needs updating
+  moduleCheck: (moduleInfo) => {
+    const localVersion = localStorage.getItem(`version:${moduleInfo.code}`);
+    return localVersion === moduleInfo.version;
+  }
+});
+```
+
+#### Custom Storage Implementation
+
+```typescript
+// Use your own storage solution (IndexedDB, custom cache, etc.)
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // Custom save function
+  saveModule: (moduleData) => {
+    myCustomCache.set(moduleData.code, {
+      digest: moduleData.digest,
+      script: moduleData.scriptText,
+      timestamp: Date.now()
+    });
+  },
+
+  // Custom load function
+  loadLocalModule: (moduleCode) => {
+    const cached = myCustomCache.get(moduleCode);
+    return cached ? cached.script : null;
+  }
+});
+```
+
+### Complete Example
+
+```typescript
+import { ModuleLoader, initializeDynaJs } from '@ticatec/dyna-js';
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+// 1. Initialize DynaJs with your base imports
+initializeDynaJs({
+  defaultImports: {
+    Dialog: DialogClass,
+    MessageBox: MessageBoxClass
+  }
+});
+
+// 2. Setup module loader
+const loadModule = async (moduleInfo) => {
+  const response = await fetch(`/api/modules/${moduleInfo.code}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ digest: moduleInfo.digest })
+  });
+
+  if (!response.ok) throw new Error('Failed to load module');
+  return response.json();
+};
+
+const moduleLoader = ModuleLoader.initialize(loadModule, {});
+
+// 3. On application startup, check for module updates
+async function initializeApp() {
+  try {
+    // Get module manifest from server
+    const manifest = await fetch('/api/modules/manifest').then(r => r.json());
+
+    // Update all modules that have changed
+    await moduleLoader.checkFreshScripts(manifest.modules);
+
+    console.log('All modules are up to date!');
+  } catch (error) {
+    console.error('Failed to update modules:', error);
+  }
+}
+
+// 4. Load and use modules on demand
+function loadUserForm() {
+  // This will use the cached version from localStorage
+  const UserForm = moduleLoader.createModule('user-form', {
+    React,
+    ReactDOM,
+    Dialog: DialogClass,
+    MessageBox: MessageBoxClass
+  });
+
+  // Subsequent calls return the same cached instance
+  const form = new UserForm();
+  form.render();
+}
+
+// Initialize
+initializeApp().then(() => {
+  loadUserForm();
+});
+```
+
+### Module Data Format
+
+Your server should return module data in this format:
+
+```typescript
+interface ModuleData {
+  code: string;        // Unique module identifier
+  digest: string;      // Hash/version identifier (e.g., MD5, SHA-256)
+  scriptText: string;  // The actual JavaScript code to execute
+}
+```
+
+### Best Practices
+
+1. **Version Control**: Use content-based hashing (MD5, SHA-256) for the digest field
+2. **Graceful Degradation**: Handle network failures when loading modules
+3. **Dependency Injection**: Pass all required dependencies in the imports object
+4. **Cache Invalidation**: Call `checkFreshScripts()` on app startup and periodically
+5. **Error Handling**: Wrap module creation in try-catch blocks
+
+```typescript
+try {
+  const module = moduleLoader.createModule('my-module', imports);
+  const instance = new module();
+  instance.run();
+} catch (error) {
+  console.error('Module failed to load or execute:', error);
+  // Fallback to default behavior
+}
+```
+
 ## Error Handling
 
 ```typescript
@@ -327,7 +527,6 @@ Full TypeScript support with comprehensive type definitions:
 ```typescript
 import { 
   DynaJs,
-  ExecutionResult,
   ExecutionOptions,
   ModuleImports 
 } from '@ticatec/dyna-js';

package/README_CN.md

@@ -11,13 +11,13 @@
 
 ## 功能特性
 
-✅ **通用兼容性** - 同时支持 Node.js 和浏览器环境
-✅ **TypeScript 支持** - 完整的类型安全和类型定义
-✅ **单例模式** - 一次初始化，全局使用
-✅ **模块导入** - 为动态代码预定义类和函数
-✅ **可配置安全性** - 对允许的 API 和操作进行细粒度控制
-✅ **多种构建格式** - 支持 CommonJS 和 ESM
-✅ **性能监控** - 内置执行时间跟踪
+✅ **通用兼容性** - 同时支持 Node.js 和浏览器环境  
+✅ **TypeScript 支持** - 完整的类型安全和类型定义  
+✅ **单例模式** - 一次初始化，全局使用  
+✅ **模块导入** - 为动态代码预定义类和函数  
+✅ **可配置安全性** - 对允许的 API 和操作进行细粒度控制  
+✅ **多种构建格式** - 支持 CommonJS 和 ESM  
+✅ **性能监控** - 内置执行时间跟踪  
 
 ## 安装
 
@@ -298,6 +298,206 @@ const validation = dynamicValidator({
 });
 ```
 
+## ModuleLoader - 动态模块管理
+
+`ModuleLoader` 是一个单例类，用于管理具有自动缓存和版本控制的动态 JavaScript 模块。它非常适合加载远程代码模块并管理它们的生命周期。
+
+### 核心特性
+
+- **单例模式** - 单个实例管理所有模块
+- **版本控制** - 基于摘要的自动新鲜度检查
+- **本地缓存** - 将模块存储在 localStorage 中以供离线访问
+- **懒加载** - 模块仅在需要时才实例化
+- **自定义钩子** - 使用自定义实现覆盖默认行为
+
+### 基础用法
+
+#### 1. 初始化 ModuleLoader
+
+```typescript
+import { ModuleLoader } from '@ticatec/dyna-js';
+
+// 定义如何从服务器加载模块
+const loadModuleFromServer = async (moduleInfo) => {
+  const response = await fetch(`/api/modules/${moduleInfo.code}`);
+  return response.json(); // 应该返回 { code, digest, scriptText }
+};
+
+// 初始化单例
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // 所有选项都是可选的 - 默认使用 localStorage
+});
+```
+
+#### 2. 检查和更新模块
+
+```typescript
+// 检查模块列表并在需要时更新
+await moduleLoader.checkFreshScripts([
+  { code: 'user-form', digest: 'abc123...' },
+  { code: 'data-grid', digest: 'def456...' },
+  { code: 'chart-widget', digest: 'ghi789...' }
+]);
+
+// 这将：
+// 1. 检查每个模块的摘要与 localStorage 中的对比
+// 2. 下载并保存已更改的模块
+// 3. 清除模块实例缓存
+```
+
+#### 3. 创建和使用模块
+
+```typescript
+// 导入模块需要的依赖项
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+// 创建模块实例
+const UserForm = moduleLoader.createModule('user-form', {
+  React,
+  ReactDOM,
+  // 添加模块需要的任何其他依赖项
+});
+
+// 使用模块（它现在已被缓存以供后续调用）
+const formInstance = new UserForm({
+  title: '用户注册',
+  onSubmit: handleSubmit
+});
+```
+
+### 高级配置
+
+#### 自定义模块检查函数
+
+```typescript
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // 自定义逻辑来检查模块是否需要更新
+  moduleCheck: (moduleInfo) => {
+    const localVersion = localStorage.getItem(`version:${moduleInfo.code}`);
+    return localVersion === moduleInfo.version;
+  }
+});
+```
+
+#### 自定义存储实现
+
+```typescript
+// 使用您自己的存储解决方案（IndexedDB、自定义缓存等）
+const moduleLoader = ModuleLoader.initialize(loadModuleFromServer, {
+  // 自定义保存函数
+  saveModule: (moduleData) => {
+    myCustomCache.set(moduleData.code, {
+      digest: moduleData.digest,
+      script: moduleData.scriptText,
+      timestamp: Date.now()
+    });
+  },
+
+  // 自定义加载函数
+  loadLocalModule: (moduleCode) => {
+    const cached = myCustomCache.get(moduleCode);
+    return cached ? cached.script : null;
+  }
+});
+```
+
+### 完整示例
+
+```typescript
+import { ModuleLoader, initializeDynaJs } from '@ticatec/dyna-js';
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+// 1. 使用基础导入初始化 DynaJs
+initializeDynaJs({
+  defaultImports: {
+    Dialog: DialogClass,
+    MessageBox: MessageBoxClass
+  }
+});
+
+// 2. 设置模块加载器
+const loadModule = async (moduleInfo) => {
+  const response = await fetch(`/api/modules/${moduleInfo.code}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ digest: moduleInfo.digest })
+  });
+
+  if (!response.ok) throw new Error('加载模块失败');
+  return response.json();
+};
+
+const moduleLoader = ModuleLoader.initialize(loadModule, {});
+
+// 3. 在应用启动时，检查模块更新
+async function initializeApp() {
+  try {
+    // 从服务器获取模块清单
+    const manifest = await fetch('/api/modules/manifest').then(r => r.json());
+
+    // 更新所有已更改的模块
+    await moduleLoader.checkFreshScripts(manifest.modules);
+
+    console.log('所有模块都是最新的！');
+  } catch (error) {
+    console.error('更新模块失败：', error);
+  }
+}
+
+// 4. 按需加载和使用模块
+function loadUserForm() {
+  // 这将使用 localStorage 中的缓存版本
+  const UserForm = moduleLoader.createModule('user-form', {
+    React,
+    ReactDOM,
+    Dialog: DialogClass,
+    MessageBox: MessageBoxClass
+  });
+
+  // 后续调用返回相同的缓存实例
+  const form = new UserForm();
+  form.render();
+}
+
+// 初始化
+initializeApp().then(() => {
+  loadUserForm();
+});
+```
+
+### 模块数据格式
+
+您的服务器应以此格式返回模块数据：
+
+```typescript
+interface ModuleData {
+  code: string;        // 唯一的模块标识符
+  digest: string;      // 哈希/版本标识符（例如 MD5、SHA-256）
+  scriptText: string;  // 要执行的实际 JavaScript 代码
+}
+```
+
+### 最佳实践
+
+1. **版本控制**：对 digest 字段使用基于内容的哈希（MD5、SHA-256）
+2. **优雅降级**：处理加载模块时的网络故障
+3. **依赖注入**：在 imports 对象中传递所有必需的依赖项
+4. **缓存失效**：在应用启动时和定期调用 `checkFreshScripts()`
+5. **错误处理**：将模块创建包装在 try-catch 块中
+
+```typescript
+try {
+  const module = moduleLoader.createModule('my-module', imports);
+  const instance = new module();
+  instance.run();
+} catch (error) {
+  console.error('模块加载或执行失败：', error);
+  // 回退到默认行为
+}
+```
+
 ## 错误处理
 
 ```typescript
@@ -327,7 +527,6 @@ try {
 ```typescript
 import {
   DynaJs,
-  ExecutionResult,
   ExecutionOptions,
   ModuleImports
 } from '@ticatec/dyna-js';

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ticatec/dyna-js",
-  "version": "0.0.4",
+  "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"