@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

package/src/plugins/processor.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { DEFAULT_ECOPAGES_WORK_DIR } from "../constants.js";
+import { GENERATED_BASE_PATHS } from "../constants";
+const PROCESSOR_ERRORS = {
+  CACHE_DIRECTORY_NOT_SET: "Cache directory not set in context"
+};
+function resolveGeneratedPath(type, options) {
+  const { root, module, subPath } = options;
+  const parts = [root, GENERATED_BASE_PATHS[type], module, subPath].filter(Boolean);
+  return path.join(...parts);
+}
+class Processor {
+  name;
+  dependencies = [];
+  context;
+  options;
+  watchConfig;
+  capabilities = [];
+  runtimeCapability;
+  constructor(config) {
+    this.name = config.name;
+    this.options = config.options;
+    this.watchConfig = config.watch;
+    this.capabilities = config.capabilities ?? [];
+    this.runtimeCapability = config.runtimeCapability;
+  }
+  setContext(appConfig) {
+    const workDir = appConfig.absolutePaths.workDir ?? path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
+    const cachePath = resolveGeneratedPath("cache", {
+      root: workDir,
+      module: this.name
+    });
+    fileSystem.ensureDir(cachePath);
+    this.context = {
+      config: appConfig,
+      rootDir: appConfig.rootDir,
+      srcDir: appConfig.absolutePaths.srcDir,
+      distDir: appConfig.absolutePaths.distDir,
+      cache: cachePath
+    };
+  }
+  /**
+   * Prepares build-facing processor contributions before config finalization.
+   *
+   * @remarks
+   * Override this when a processor must compute runtime/build plugins or other
+   * manifest-owned state before startup. Runtime-only work such as cache
+   * warming or watcher registration should stay in `setup()`.
+   */
+  async prepareBuildContributions() {
+  }
+  getCachePath(key) {
+    return `${this.context?.cache}/${key}`;
+  }
+  async readCache(key) {
+    const cachePath = this.getCachePath(key);
+    try {
+      const data = await fileSystem.readFile(cachePath);
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async writeCache(key, data) {
+    if (!this.context?.cache) {
+      throw new Error(PROCESSOR_ERRORS.CACHE_DIRECTORY_NOT_SET);
+    }
+    const cachePath = this.getCachePath(key);
+    fileSystem.write(cachePath, JSON.stringify(data, null, 2));
+  }
+  getWatchConfig() {
+    return this.watchConfig;
+  }
+  getDependencies() {
+    return this.dependencies;
+  }
+  getName() {
+    return this.name;
+  }
+  getAssetCapabilities() {
+    return this.capabilities;
+  }
+  matchesFileFilter(_filepath) {
+    return true;
+  }
+  canProcessAsset(kind, filepath) {
+    const capabilities = this.getAssetCapabilities();
+    if (capabilities.length === 0) {
+      return false;
+    }
+    const matchingKind = capabilities.filter((capability) => capability.kind === kind);
+    if (matchingKind.length === 0) {
+      return false;
+    }
+    if (!filepath) {
+      return true;
+    }
+    return matchingKind.some((capability) => this.matchesCapabilityExtensions(filepath, capability.extensions));
+  }
+  matchesCapabilityExtensions(filepath, extensions) {
+    if (!extensions || extensions.length === 0) {
+      return true;
+    }
+    const normalizedExt = path.extname(filepath).toLowerCase();
+    return extensions.some((rawPattern) => {
+      const pattern = this.normalizeExtensionPattern(rawPattern);
+      if (!pattern) {
+        return false;
+      }
+      if (pattern === "*") {
+        return true;
+      }
+      const groupedMatch = pattern.match(/^\*\.\{(.+)\}$/);
+      if (groupedMatch) {
+        const groupItems = groupedMatch[1].split(",").map((item) => this.normalizeExtensionPattern(item)).filter(Boolean);
+        return groupItems.some((item) => normalizedExt === item || normalizedExt === `.${item}`);
+      }
+      if (pattern.startsWith("*")) {
+        const suffix = pattern.slice(1);
+        return normalizedExt.endsWith(suffix);
+      }
+      if (pattern.startsWith(".")) {
+        return normalizedExt === pattern;
+      }
+      return normalizedExt === `.${pattern}`;
+    });
+  }
+  normalizeExtensionPattern(rawPattern) {
+    return rawPattern.trim().toLowerCase();
+  }
+}
+export {
+  PROCESSOR_ERRORS,
+  Processor
+};

package/src/plugins/runtime-capability.d.ts

@@ -0,0 +1,9 @@
+export type RuntimeCapabilityTag = 'bun-only' | 'node-compatible' | 'requires-native-bun-api' | 'requires-node-builtins';
+/**
+ * Declares the runtime assumptions a plugin makes so config finalization can
+ * reject incompatible startup environments before bootstrapping the app.
+ */
+export interface RuntimeCapabilityDeclaration {
+    tags: RuntimeCapabilityTag[];
+    minRuntimeVersion?: string;
+}