@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-FF3Q7ADR.js

@@ -1,380 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-
-// src/interop/Interoperability.ts
-var ModuleResolver = class {
-  constructor(basePath = process.cwd()) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.resolvedPaths = /* @__PURE__ */ new Map();
-    this.basePath = basePath;
-  }
-  /**
-   * Resolve module path
-   */
-  resolveModule(modulePath, fromPath) {
-    const cacheKey = `${modulePath}:${fromPath || "root"}`;
-    if (this.resolvedPaths.has(cacheKey)) {
-      return this.resolvedPaths.get(cacheKey);
-    }
-    const resolved = this.performResolve(modulePath, fromPath);
-    this.resolvedPaths.set(cacheKey, resolved);
-    return resolved;
-  }
-  /**
-   * Perform actual module resolution
-   */
-  performResolve(modulePath, fromPath) {
-    if (this.isBuiltinModule(modulePath)) {
-      return modulePath;
-    }
-    if (modulePath.startsWith(".")) {
-      const basePath = fromPath ? path.dirname(fromPath) : this.basePath;
-      const resolved = path.resolve(basePath, modulePath);
-      return this.findModuleFile(resolved);
-    }
-    if (modulePath.startsWith("@")) {
-      return this.resolveNodeModule(modulePath);
-    }
-    return this.resolveNodeModule(modulePath);
-  }
-  /**
-   * Check if built-in module
-   */
-  isBuiltinModule(modulePath) {
-    const builtins = ["fs", "path", "crypto", "util", "stream", "events"];
-    return builtins.includes(modulePath);
-  }
-  /**
-   * Resolve from node_modules
-   */
-  resolveNodeModule(modulePath) {
-    let current = this.basePath;
-    while (current !== path.dirname(current)) {
-      const nodeModulesPath = path.join(current, "node_modules", modulePath);
-      if (fs.existsSync(nodeModulesPath)) {
-        return nodeModulesPath;
-      }
-      const packageJsonPath = path.join(nodeModulesPath, "package.json");
-      if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-        return this.findModuleFile(path.join(nodeModulesPath, packageJson.main || "index.js"));
-      }
-      current = path.dirname(current);
-    }
-    throw new Error(`Module not found: ${modulePath}`);
-  }
-  /**
-   * Find module file with various extensions
-   */
-  findModuleFile(basePath) {
-    const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-    if (fs.existsSync(basePath)) {
-      return basePath;
-    }
-    for (const ext of extensions) {
-      const withExt = basePath + ext;
-      if (fs.existsSync(withExt)) {
-        return withExt;
-      }
-    }
-    const indexPath = path.join(basePath, "index");
-    for (const ext of extensions) {
-      const withExt = indexPath + ext;
-      if (fs.existsSync(withExt)) {
-        return withExt;
-      }
-    }
-    throw new Error(`Cannot resolve file: ${basePath}`);
-  }
-  /**
-   * Load module (with caching)
-   */
-  loadModule(modulePath, fromPath) {
-    const resolved = this.resolveModule(modulePath, fromPath);
-    const cacheKey = resolved;
-    if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey);
-    }
-    const module = {
-      path: resolved,
-      exports: {}
-    };
-    this.cache.set(cacheKey, module);
-    return module;
-  }
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.cache.clear();
-    this.resolvedPaths.clear();
-  }
-};
-var ExportImportHandler = class {
-  constructor() {
-    this.exports = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Define named export
-   */
-  defineExport(modulePath, name, value) {
-    if (!this.exports.has(modulePath)) {
-      this.exports.set(modulePath, /* @__PURE__ */ new Map());
-    }
-    this.exports.get(modulePath).set(name, value);
-  }
-  /**
-   * Get named export
-   */
-  getExport(modulePath, name) {
-    const moduleExports = this.exports.get(modulePath);
-    if (!moduleExports) {
-      throw new Error(`Module not found: ${modulePath}`);
-    }
-    if (!moduleExports.has(name)) {
-      throw new Error(`Named export '${name}' not found in ${modulePath}`);
-    }
-    return moduleExports.get(name);
-  }
-  /**
-   * Get all exports from module
-   */
-  getAllExports(modulePath) {
-    const moduleExports = this.exports.get(modulePath);
-    if (!moduleExports) {
-      return {};
-    }
-    const result = {};
-    for (const [name, value] of moduleExports) {
-      result[name] = value;
-    }
-    return result;
-  }
-  /**
-   * Check if export exists
-   */
-  hasExport(modulePath, name) {
-    return this.exports.has(modulePath) && this.exports.get(modulePath).has(name);
-  }
-};
-var AsyncFunctionHandler = class {
-  /**
-   * Wrap async function for HoloScript
-   */
-  wrapAsyncFunction(fn) {
-    return async (...args) => {
-      try {
-        return await fn(...args);
-      } catch (error) {
-        throw this.normalizeError(error);
-      }
-    };
-  }
-  /**
-   * Check if function is async
-   */
-  isAsync(fn) {
-    if (typeof fn !== "function") {
-      return false;
-    }
-    const fnStr = fn.toString().trim();
-    return fnStr.startsWith("async ") || fn.constructor.name === "AsyncFunction";
-  }
-  /**
-   * Convert callback to promise
-   */
-  callbackToPromise(fn) {
-    return new Promise((resolve2, reject) => {
-      fn((err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve2(result);
-        }
-      });
-    });
-  }
-  /**
-   * Normalize error from async function
-   */
-  normalizeError(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-    if (typeof error === "string") {
-      return new Error(error);
-    }
-    return new Error(JSON.stringify(error));
-  }
-};
-var ErrorBoundary = class {
-  constructor(onError) {
-    this.errors = [];
-    this.onError = onError;
-  }
-  /**
-   * Wrap function with error boundary
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  wrap(fn) {
-    return ((...args) => {
-      try {
-        const result = fn(...args);
-        if (result instanceof Promise) {
-          return result.catch((error) => {
-            this.handleError(error);
-            throw error;
-          });
-        }
-        return result;
-      } catch (error) {
-        this.handleError(error);
-        throw error;
-      }
-    });
-  }
-  /**
-   * Wrap async function with error boundary
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  wrapAsync(fn) {
-    return (async (...args) => {
-      try {
-        return await fn(...args);
-      } catch (error) {
-        this.handleError(error);
-        throw error;
-      }
-    });
-  }
-  /**
-   * Execute function in boundary
-   */
-  execute(fn) {
-    try {
-      return fn();
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-  /**
-   * Execute async function in boundary
-   */
-  async executeAsync(fn) {
-    try {
-      return await fn();
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-  /**
-   * Handle error
-   */
-  handleError(error) {
-    const normalized = this.normalizeError(error);
-    this.errors.push(normalized);
-    if (this.onError) {
-      this.onError(normalized);
-    }
-  }
-  /**
-   * Get errors
-   */
-  getErrors() {
-    return [...this.errors];
-  }
-  /**
-   * Clear errors
-   */
-  clearErrors() {
-    this.errors = [];
-  }
-  /**
-   * Normalize error
-   */
-  normalizeError(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-    if (typeof error === "string") {
-      return new Error(error);
-    }
-    return new Error(JSON.stringify(error));
-  }
-};
-var TypeScriptTypeLoader = class {
-  /**
-   * Load types from TypeScript declaration file
-   */
-  loadTypes(_filePath) {
-    const types = /* @__PURE__ */ new Map();
-    return types;
-  }
-  /**
-   * Convert TypeScript type to HoloScript type
-   */
-  convertType(tsType) {
-    const mapping = {
-      string: "text",
-      number: "numeric",
-      boolean: "logical",
-      void: "void",
-      any: "dynamic",
-      unknown: "dynamic",
-      null: "null",
-      undefined: "void"
-    };
-    if (typeof tsType === "string") {
-      return mapping[tsType] || tsType;
-    }
-    if (Array.isArray(tsType)) {
-      return {
-        kind: "array",
-        elementType: this.convertType(tsType[0])
-      };
-    }
-    if (typeof tsType === "object") {
-      return {
-        kind: "object",
-        properties: Object.entries(tsType).reduce(
-          (acc, [key, val]) => {
-            acc[key] = this.convertType(val);
-            return acc;
-          },
-          {}
-        )
-      };
-    }
-    return tsType;
-  }
-};
-var InteropContext = class {
-  constructor(basePath) {
-    this.moduleResolver = new ModuleResolver(basePath);
-    this.exportImportHandler = new ExportImportHandler();
-    this.asyncHandler = new AsyncFunctionHandler();
-    this.errorBoundary = new ErrorBoundary();
-    this.typeLoader = new TypeScriptTypeLoader();
-  }
-  getModuleResolver() {
-    return this.moduleResolver;
-  }
-  getExportImportHandler() {
-    return this.exportImportHandler;
-  }
-  getAsyncHandler() {
-    return this.asyncHandler;
-  }
-  getErrorBoundary() {
-    return this.errorBoundary;
-  }
-  getTypeLoader() {
-    return this.typeLoader;
-  }
-};
-
-export { AsyncFunctionHandler, ErrorBoundary, ExportImportHandler, InteropContext, ModuleResolver, TypeScriptTypeLoader };
-//# sourceMappingURL=chunk-FF3Q7ADR.js.map
-//# sourceMappingURL=chunk-FF3Q7ADR.js.map