bloody-engine 1.0.0 → 1.0.2

package/dist/node/node-resource-loader-MzkD-IGo.js

@@ -1,166 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-class NodeResourceLoader {
-  /**
-   * Create a new Node.js resource loader
-   * @param baseDir Optional base directory for resolving relative paths (defaults to current working directory)
-   */
-  constructor(baseDir = process.cwd()) {
-    this.baseDir = baseDir;
-  }
-  /**
-   * Resolve a relative path against the base directory
-   * @param filePath Relative or absolute file path
-   * @returns Resolved absolute file path
-   */
-  resolvePath(filePath) {
-    if (path.isAbsolute(filePath)) {
-      return path.normalize(filePath);
-    }
-    return path.normalize(path.join(this.baseDir, filePath));
-  }
-  /**
-   * Load a single resource from a file
-   * @param filePath File path (relative or absolute)
-   * @param options Optional loading configuration
-   * @returns Promise resolving to the file content
-   */
-  async load(filePath, options) {
-    const resolvedPath = this.resolvePath(filePath);
-    const encoding = options?.encoding || "utf-8";
-    try {
-      const content = await fs.readFile(resolvedPath, encoding);
-      return content;
-    } catch (error) {
-      if (error instanceof Error) {
-        const errorCode = error.code;
-        if (errorCode === "ENOENT") {
-          throw new Error(
-            `File not found: ${resolvedPath} (resolved from: ${filePath})`
-          );
-        }
-        if (errorCode === "EACCES") {
-          throw new Error(
-            `Permission denied reading file: ${resolvedPath}`
-          );
-        }
-        if (errorCode === "EISDIR") {
-          throw new Error(
-            `Path is a directory, not a file: ${resolvedPath}`
-          );
-        }
-        throw new Error(
-          `Failed to load resource from ${resolvedPath}: ${error.message}`
-        );
-      }
-      throw new Error(
-        `Failed to load resource from ${resolvedPath}: Unknown error`
-      );
-    }
-  }
-  /**
-   * Load multiple resources in parallel
-   * @param filePaths Array of file paths
-   * @param options Optional loading configuration
-   * @returns Promise resolving to array of load results
-   */
-  async loadMultiple(filePaths, options) {
-    const promises = filePaths.map(async (filePath) => {
-      try {
-        const data = await this.load(filePath, options);
-        return {
-          data,
-          path: filePath,
-          success: true
-        };
-      } catch (error) {
-        return {
-          data: "",
-          path: filePath,
-          success: false,
-          error: error instanceof Error ? error.message : String(error)
-        };
-      }
-    });
-    return Promise.all(promises);
-  }
-  /**
-   * Check if the path is valid for loading in Node.js
-   * @param filePath File path to check
-   * @returns true if the path can be loaded
-   */
-  canLoad(filePath) {
-    const validPatterns = [
-      /^\//,
-      // Unix absolute paths
-      /^[a-zA-Z]:/,
-      // Windows absolute paths (e.g., C:\)
-      /^\.\.?\//,
-      // Relative paths starting with ./ or ../
-      /^[^/\\]+\//
-      // Relative paths without explicit prefix (e.g., "shaders/")
-    ];
-    return validPatterns.some((pattern) => pattern.test(filePath));
-  }
-  /**
-   * Check if a file exists without loading it
-   * @param filePath File path to check
-   * @returns Promise resolving to true if file exists
-   */
-  async exists(filePath) {
-    const resolvedPath = this.resolvePath(filePath);
-    try {
-      await fs.access(resolvedPath, fs.constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get file statistics (size, modification time, etc.)
-   * @param filePath File path to check
-   * @returns Promise resolving to file stats
-   */
-  async getStats(filePath) {
-    const resolvedPath = this.resolvePath(filePath);
-    return fs.stat(resolvedPath);
-  }
-  /**
-   * Set a new base directory for resolving relative paths
-   * @param baseDir New base directory
-   */
-  setBaseDir(baseDir) {
-    this.baseDir = baseDir;
-  }
-  /**
-   * Get the current base directory
-   * @returns Current base directory
-   */
-  getBaseDir() {
-    return this.baseDir;
-  }
-  /**
-   * List all files in a directory
-   * @param dirPath Directory path to list
-   * @param recursive Whether to recursively list subdirectories (default: false)
-   * @returns Promise resolving to array of file paths
-   */
-  async listDirectory(dirPath, recursive = false) {
-    const resolvedPath = this.resolvePath(dirPath);
-    const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-      const fullPath = path.join(resolvedPath, entry.name);
-      if (entry.isDirectory() && recursive) {
-        const subFiles = await this.listDirectory(fullPath, true);
-        files.push(...subFiles);
-      } else if (entry.isFile()) {
-        files.push(fullPath);
-      }
-    }
-    return files;
-  }
-}
-export {
-  NodeResourceLoader
-};

package/dist/node/resource-loader-factory-DQ-PAVcN.js

@@ -1,93 +0,0 @@
-var Environment = /* @__PURE__ */ ((Environment2) => {
-  Environment2["BROWSER"] = "browser";
-  Environment2["NODE"] = "node";
-  Environment2["UNKNOWN"] = "unknown";
-  return Environment2;
-})(Environment || {});
-class ResourceLoaderFactory {
-  /**
-   * Detect the current runtime environment
-   * @returns The detected environment type
-   */
-  static detectEnvironment() {
-    if (typeof window !== "undefined" && typeof window.document !== "undefined" && typeof fetch !== "undefined") {
-      return "browser";
-    }
-    if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
-      return "node";
-    }
-    return "unknown";
-  }
-  /**
-   * Check if the current environment is a browser
-   * @returns true if running in a browser
-   */
-  static isBrowser() {
-    return this.detectEnvironment() === "browser";
-  }
-  /**
-   * Check if the current environment is Node.js
-   * @returns true if running in Node.js
-   */
-  static isNode() {
-    return this.detectEnvironment() === "node";
-  }
-  /**
-   * Create a resource loader for the current environment
-   * @param options Optional factory configuration
-   * @returns A resource loader instance appropriate for the current platform
-   * @throws Error if the environment is not supported
-   */
-  static async create(options) {
-    const environment = options?.forceEnvironment || this.detectEnvironment();
-    switch (environment) {
-      case "browser":
-        return await this.createBrowserLoader(options);
-      case "node":
-        return await this.createNodeLoader(options);
-      case "unknown":
-        throw new Error(
-          "Unsupported environment: Unable to determine runtime environment. Please specify forceEnvironment in options."
-        );
-      default:
-        throw new Error(`Unsupported environment: ${environment}`);
-    }
-  }
-  /**
-   * Create a browser resource loader
-   * @param options Optional factory configuration
-   * @returns A browser resource loader instance
-   */
-  static async createBrowserLoader(options) {
-    const { BrowserResourceLoader: Loader } = await import("./browser-resource-loader-D51BD3k_.js");
-    return new Loader(options?.baseUrl, options?.timeout);
-  }
-  /**
-   * Create a Node.js resource loader
-   * @param options Optional factory configuration
-   * @returns A Node.js resource loader instance
-   */
-  static async createNodeLoader(options) {
-    const { NodeResourceLoader: Loader } = await import("./node-resource-loader-MzkD-IGo.js");
-    return new Loader(options?.baseDir);
-  }
-  /**
-   * Create a resource loader with automatic fallback
-   * If the preferred loader is not available, falls back to the available loader
-   * @param preferredEnvironment Preferred environment
-   * @param options Optional factory configuration
-   * @returns A resource loader instance
-   */
-  static async createWithFallback(preferredEnvironment, options) {
-    try {
-      options = { ...options, forceEnvironment: preferredEnvironment };
-      return await this.create(options);
-    } catch {
-      return await this.create({ ...options, forceEnvironment: void 0 });
-    }
-  }
-}
-export {
-  Environment,
-  ResourceLoaderFactory
-};

package/dist/node/resource-pipeline-Dac9qRso.js

@@ -1,211 +0,0 @@
-class ResourceCache {
-  constructor(enabled = true) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.enabled = enabled;
-  }
-  get(key) {
-    if (!this.enabled) return void 0;
-    return this.cache.get(key);
-  }
-  set(key, value) {
-    if (this.enabled) {
-      this.cache.set(key, value);
-    }
-  }
-  has(key) {
-    if (!this.enabled) return false;
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  size() {
-    return this.cache.size;
-  }
-  enable() {
-    this.enabled = true;
-  }
-  disable() {
-    this.enabled = false;
-  }
-}
-class ResourcePipeline {
-  /**
-   * Create a new resource loading pipeline
-   * @param loader Resource loader instance
-   * @param options Pipeline configuration options
-   */
-  constructor(loader, options) {
-    this.loader = loader;
-    this.concurrency = options?.concurrency ?? 10;
-    this.cache = new ResourceCache(options?.cache ?? true);
-  }
-  /**
-   * Load a single resource with caching support
-   * @param path Resource path or URL
-   * @param options Optional loading options
-   * @returns Promise resolving to the resource content
-   */
-  async load(path, options) {
-    const cached = this.cache.get(path);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const content = await this.loader.load(path, options);
-    this.cache.set(path, content);
-    return content;
-  }
-  /**
-   * Load multiple resources with concurrency control
-   * @param paths Array of resource paths
-   * @param options Optional loading options
-   * @returns Promise resolving to batch load result
-   */
-  async loadBatch(paths, options) {
-    const succeeded = /* @__PURE__ */ new Map();
-    const failed = /* @__PURE__ */ new Map();
-    for (let i = 0; i < paths.length; i += this.concurrency) {
-      const batch = paths.slice(i, i + this.concurrency);
-      const results = await this.loader.loadMultiple(batch, options);
-      for (const result of results) {
-        if (result.success) {
-          succeeded.set(result.path, result.data);
-          this.cache.set(result.path, result.data);
-        } else {
-          failed.set(result.path, result.error || "Unknown error");
-        }
-      }
-    }
-    return {
-      succeeded,
-      failed,
-      total: paths.length,
-      successCount: succeeded.size,
-      failureCount: failed.size
-    };
-  }
-  /**
-   * Load a shader from separate vertex and fragment files
-   * @param vertexPath Path to vertex shader file
-   * @param fragmentPath Path to fragment shader file
-   * @param options Optional loading options
-   * @returns Promise resolving to shader source code
-   */
-  async loadShader(vertexPath, fragmentPath, options) {
-    const [vertex, fragment] = await Promise.all([
-      this.load(vertexPath, options),
-      this.load(fragmentPath, options)
-    ]);
-    return { vertex, fragment };
-  }
-  /**
-   * Load multiple shaders
-   * @param shaders Array of shader definitions
-   * @param options Optional loading options
-   * @returns Promise resolving to array of named shader sources
-   */
-  async loadShaders(shaders, options) {
-    const results = await Promise.all(
-      shaders.map(async (shader) => {
-        const source = await this.loadShader(
-          shader.vertex,
-          shader.fragment,
-          options
-        );
-        return {
-          name: shader.name,
-          ...source
-        };
-      })
-    );
-    return results;
-  }
-  /**
-   * Load resources from a manifest file
-   * @param manifestPath Path to JSON manifest file
-   * @param options Optional loading options
-   * @returns Promise resolving to batch load result
-   */
-  async loadFromManifest(manifestPath, options) {
-    const manifestContent = await this.load(manifestPath, options);
-    const manifest = JSON.parse(manifestContent);
-    return this.loadBatch(manifest.resources, options);
-  }
-  /**
-   * Preload resources for faster access later
-   * @param paths Array of resource paths to preload
-   * @param options Optional loading options
-   * @returns Promise resolving when all resources are loaded
-   */
-  async preload(paths, options) {
-    await this.loadBatch(paths, options);
-  }
-  /**
-   * Check if a resource is cached
-   * @param path Resource path
-   * @returns true if the resource is in the cache
-   */
-  isCached(path) {
-    return this.cache.has(path);
-  }
-  /**
-   * Get a resource from cache without loading
-   * @param path Resource path
-   * @returns Cached content or undefined if not cached
-   */
-  getCached(path) {
-    return this.cache.get(path);
-  }
-  /**
-   * Clear the resource cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get cache statistics
-   * @returns Number of cached resources
-   */
-  getCacheSize() {
-    return this.cache.size();
-  }
-  /**
-   * Enable caching
-   */
-  enableCache() {
-    this.cache.enable();
-  }
-  /**
-   * Disable caching
-   */
-  disableCache() {
-    this.cache.disable();
-  }
-  /**
-   * Set the maximum concurrency for batch operations
-   * @param concurrency Maximum concurrent loads
-   */
-  setConcurrency(concurrency) {
-    this.concurrency = Math.max(1, concurrency);
-  }
-  /**
-   * Get the underlying resource loader
-   * @returns The resource loader instance
-   */
-  getLoader() {
-    return this.loader;
-  }
-}
-async function createResourcePipeline(options) {
-  const { ResourceLoaderFactory } = await import("./resource-loader-factory-DQ-PAVcN.js");
-  const loader = await ResourceLoaderFactory.create({
-    baseUrl: options?.baseUrl,
-    baseDir: options?.baseDir,
-    timeout: options?.timeout
-  });
-  return new ResourcePipeline(loader, options);
-}
-export {
-  ResourcePipeline,
-  createResourcePipeline
-};