@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/plugins/eco-component-meta-plugin.js

@@ -1,157 +0,0 @@
-import path from "node:path";
-import { parseSync } from "oxc-parser";
-import { fileSystem } from "@ecopages/file-system";
-import { rapidhash } from "../utils/hash.js";
-const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
-const VALID_LOADER_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-function hasValidLoaderExtension(ext) {
-  for (const validExt of VALID_LOADER_EXTENSIONS) {
-    if (ext.endsWith(validExt)) {
-      return true;
-    }
-  }
-  return false;
-}
-function buildExtensionToIntegrationMap(integrations) {
-  const mapping = [];
-  for (const integration of integrations) {
-    for (const ext of integration.extensions) {
-      mapping.push([ext, integration.name]);
-    }
-  }
-  mapping.sort((a, b) => b[0].length - a[0].length);
-  return mapping;
-}
-function detectIntegration(filePath, extensionToIntegration) {
-  for (const [ext, integration] of extensionToIntegration) {
-    if (filePath.endsWith(ext)) {
-      return integration;
-    }
-  }
-  return "ghtml";
-}
-function createExtensionPattern(extensions) {
-  if (extensions.length === 0) {
-    throw new Error("[eco-component-meta-plugin] No extensions configured. At least one integration is required.");
-  }
-  const uniqueExtensions = [...new Set(extensions)];
-  const escaped = uniqueExtensions.map((ext) => ext.replace(REGEX_SPECIAL_CHARS, "\\$&"));
-  return new RegExp(`(${escaped.join("|")})(\\?.*)?$`);
-}
-function createEcoComponentMetaPlugin(options) {
-  return {
-    name: "eco-component-meta-plugin",
-    setup(build) {
-      const allExtensions = options.config.integrations.flatMap((integration) => integration.extensions).filter(hasValidLoaderExtension);
-      if (allExtensions.length === 0) {
-        return;
-      }
-      const extensionPattern = createExtensionPattern(allExtensions);
-      const extensionToIntegration = buildExtensionToIntegrationMap(options.config.integrations);
-      build.onLoad({ filter: extensionPattern }, (args) => {
-        const filePath = args.path.split("?")[0];
-        const contents = fileSystem.readFileSync(filePath);
-        const integration = detectIntegration(filePath, extensionToIntegration);
-        const transformedContents = injectEcoMeta(contents, filePath, integration);
-        const ext = path.extname(filePath).slice(1);
-        return {
-          contents: transformedContents,
-          loader: ext || "ts"
-        };
-      });
-    }
-  };
-}
-function findInjectionPoints(node, insertions, injection, isInsideEcoComponent = false) {
-  if (!node || typeof node !== "object") return;
-  const n = node;
-  if (n.type === "CallExpression") {
-    const callee = n.callee;
-    if (callee?.type === "MemberExpression" || callee?.type === "StaticMemberExpression") {
-      const obj = callee.object;
-      const prop = callee.property;
-      if (obj?.type === "Identifier" && obj?.name === "eco" && (prop?.name === "page" || prop?.name === "component")) {
-        const args = n.arguments;
-        const firstArg = args?.[0];
-        if (firstArg?.type === "ObjectExpression") {
-          const start = firstArg.start;
-          if (typeof start === "number") {
-            insertions.push({ position: start + 1, text: injection });
-          }
-        }
-      }
-    }
-  }
-  if (n.type === "AssignmentExpression") {
-    const left = n.left;
-    const right = n.right;
-    if (left?.type === "MemberExpression" || left?.type === "StaticMemberExpression") {
-      const prop = left.property;
-      if (prop?.name === "config" && right?.type === "ObjectExpression") {
-        const start = right.start;
-        if (typeof start === "number") {
-          insertions.push({ position: start + 1, text: injection });
-        }
-      }
-    }
-  }
-  if (n.type === "ObjectProperty" || n.type === "Property") {
-    const key = n.key;
-    const value = n.value;
-    if ((key?.type === "Identifier" || key?.type === "IdentifierName") && key?.name === "config" && value?.type === "ObjectExpression" && isInsideEcoComponent) {
-      const start = value.start;
-      if (typeof start === "number") {
-        insertions.push({ position: start + 1, text: injection });
-      }
-    }
-  }
-  let childIsInsideEcoComponent = isInsideEcoComponent;
-  if (n.type === "VariableDeclarator") {
-    const id = n.id;
-    const typeAnnotation = id?.typeAnnotation;
-    if (typeAnnotation) {
-      const typeStr = JSON.stringify(typeAnnotation);
-      if (typeStr.includes("EcoComponent")) {
-        childIsInsideEcoComponent = true;
-      }
-    }
-  }
-  for (const key in n) {
-    if (key === "start" || key === "end" || key === "type") continue;
-    const value = n[key];
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        findInjectionPoints(child, insertions, injection, childIsInsideEcoComponent);
-      }
-    } else if (typeof value === "object" && value !== null) {
-      findInjectionPoints(value, insertions, injection, childIsInsideEcoComponent);
-    }
-  }
-}
-function injectEcoMeta(contents, filePath, integration) {
-  const result = parseSync(filePath, contents);
-  if (result.errors.length > 0) {
-    console.warn(`[eco-component-meta-plugin] Parse errors in ${filePath}:`, result.errors);
-    return contents;
-  }
-  const ast = result.program;
-  const id = rapidhash(filePath).toString(36);
-  const injection = ` __eco: { id: "${id}", file: "${filePath}", integration: "${integration}" },`;
-  const insertions = [];
-  findInjectionPoints(ast, insertions, injection);
-  if (insertions.length === 0) {
-    return contents;
-  }
-  insertions.sort((a, b) => b.position - a.position);
-  let transformed = contents;
-  for (const { position, text } of insertions) {
-    transformed = transformed.slice(0, position) + text + transformed.slice(position);
-  }
-  return transformed;
-}
-var eco_component_meta_plugin_default = createEcoComponentMetaPlugin;
-export {
-  createEcoComponentMetaPlugin,
-  eco_component_meta_plugin_default as default,
-  injectEcoMeta
-};

package/src/plugins/integration-plugin.d.ts

@@ -1,102 +0,0 @@
-import type { EcoBuildPlugin } from '../build/build-types';
-import type { EcoPagesAppConfig, IHmrManager } from '../internal-types';
-import type { HmrStrategy } from '../hmr/hmr-strategy';
-import type { EcoComponent, EcoPagesElement } from '../public-types';
-import type { IntegrationRenderer } from '../route-renderer/integration-renderer';
-import { AssetProcessingService } from '../services/asset-processing-service/asset-processing.service';
-import type { AssetDefinition, ProcessedAsset } from '../services/asset-processing-service/assets.types';
-export declare const INTEGRATION_PLUGIN_ERRORS: {
-    readonly NOT_INITIALIZED_WITH_APP_CONFIG: "Plugin not initialized with app config";
-    readonly NOT_INITIALIZED_WITH_ASSET_SERVICE: "Plugin not initialized with asset dependency service";
-};
-export interface IntegrationPluginConfig {
-    /**
-     * The name of the integration plugin.
-     */
-    name: string;
-    /**
-     * The extensions that this plugin supports (e.g., ['.kita.js', '.kita.tsx']).
-     */
-    extensions: string[];
-    /**
-     * The dependencies that this plugin requires on a global level.
-     * These dependencies will be resolved during the setup process and injected into the global scope of the application.
-     * They are not specific to any particular page or component.
-     */
-    integrationDependencies?: AssetDefinition[];
-    /**
-     * The strategy to use for static building.
-     * - 'render': Execute component function directly (faster, efficient).
-     * - 'fetch': Start server and fetch URL (slower, needed for some SSR like Lit).
-     * @default 'render'
-     */
-    staticBuildStep?: 'render' | 'fetch';
-}
-/**
- * Metadata used by integration-owned boundary policy.
- *
- * This payload describes the currently active integration pass together with the
- * target component boundary being entered.
- */
-export type ComponentBoundaryPolicyInput = {
-    currentIntegration: string;
-    targetIntegration?: string;
-    component: EcoComponent;
-};
-type RendererClass<C> = new (options: {
-    appConfig: EcoPagesAppConfig;
-    assetProcessingService: AssetProcessingService;
-    resolvedIntegrationDependencies: ProcessedAsset[];
-    runtimeOrigin: string;
-}) => IntegrationRenderer<C>;
-export declare abstract class IntegrationPlugin<C = EcoPagesElement> {
-    readonly name: string;
-    readonly extensions: string[];
-    abstract renderer: RendererClass<C>;
-    readonly staticBuildStep: 'render' | 'fetch';
-    protected integrationDependencies: AssetDefinition[];
-    protected resolvedIntegrationDependencies: ProcessedAsset[];
-    protected options?: Record<string, unknown>;
-    protected appConfig?: EcoPagesAppConfig;
-    protected assetProcessingService?: AssetProcessingService;
-    protected hmrManager?: IHmrManager;
-    runtimeOrigin: string;
-    get plugins(): EcoBuildPlugin[];
-    constructor(config: IntegrationPluginConfig);
-    setConfig(appConfig: EcoPagesAppConfig): void;
-    setRuntimeOrigin(runtimeOrigin: string): void;
-    /**
-     * Returns an HMR strategy for this integration, if applicable.
-     * The strategy will be registered with the HmrManager during initialization.
-     *
-     * @returns HmrStrategy instance or undefined if no custom HMR handling needed
-     *
-     * @example
-     * ```typescript
-     * getHmrStrategy(): HmrStrategy {
-     *   const context = this.hmrManager!.getDefaultContext();
-     *   return new ReactHmrStrategy(context);
-     * }
-     * ```
-     */
-    getHmrStrategy?(): HmrStrategy | undefined;
-    setHmrManager(hmrManager: IHmrManager): void;
-    initializeAssetDefinitionService(): void;
-    getResolvedIntegrationDependencies(): ProcessedAsset[];
-    initializeRenderer(): IntegrationRenderer<C>;
-    /**
-     * Declares whether a component boundary targeting this integration should be
-     * deferred through the marker pipeline.
-     *
-     * The default implementation never defers. Integrations that require deferred
-     * subtree rendering should override this method and return `true` when their
-     * boundary must be resolved during the marker graph stage.
-     *
-     * @param input Boundary metadata for the current render pass.
-     * @returns `true` when the boundary should be deferred; otherwise `false`.
-     */
-    shouldDeferComponentBoundary(_input: ComponentBoundaryPolicyInput): boolean;
-    setup(): Promise<void>;
-    teardown(): Promise<void>;
-}
-export {};

package/src/plugins/integration-plugin.js

@@ -1,100 +0,0 @@
-import { AssetProcessingService } from "../services/asset-processing-service/asset-processing.service";
-const INTEGRATION_PLUGIN_ERRORS = {
-  NOT_INITIALIZED_WITH_APP_CONFIG: "Plugin not initialized with app config",
-  NOT_INITIALIZED_WITH_ASSET_SERVICE: "Plugin not initialized with asset dependency service"
-};
-class IntegrationPlugin {
-  name;
-  extensions;
-  staticBuildStep;
-  integrationDependencies;
-  resolvedIntegrationDependencies = [];
-  options;
-  appConfig;
-  assetProcessingService;
-  hmrManager;
-  get plugins() {
-    return [];
-  }
-  constructor(config) {
-    this.name = config.name;
-    this.extensions = config.extensions;
-    this.integrationDependencies = config.integrationDependencies || [];
-    this.staticBuildStep = config.staticBuildStep || "render";
-  }
-  setConfig(appConfig) {
-    this.appConfig = appConfig;
-    this.initializeAssetDefinitionService();
-  }
-  setRuntimeOrigin(runtimeOrigin) {
-    this.runtimeOrigin = runtimeOrigin;
-  }
-  setHmrManager(hmrManager) {
-    this.hmrManager = hmrManager;
-    const strategy = this.getHmrStrategy?.();
-    if (strategy) {
-      hmrManager.registerStrategy(strategy);
-    }
-    if (this.assetProcessingService) {
-      this.assetProcessingService.setHmrManager(hmrManager);
-    }
-  }
-  initializeAssetDefinitionService() {
-    if (!this.appConfig) throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
-    this.assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
-    if (this.hmrManager) {
-      this.assetProcessingService.setHmrManager(this.hmrManager);
-    }
-  }
-  getResolvedIntegrationDependencies() {
-    return this.resolvedIntegrationDependencies;
-  }
-  initializeRenderer() {
-    if (!this.appConfig) {
-      throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
-    }
-    const assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
-    if (this.hmrManager) {
-      assetProcessingService.setHmrManager(this.hmrManager);
-    }
-    const renderer = new this.renderer({
-      appConfig: this.appConfig,
-      assetProcessingService,
-      resolvedIntegrationDependencies: this.resolvedIntegrationDependencies,
-      runtimeOrigin: this.runtimeOrigin
-    });
-    if (this.hmrManager) {
-      renderer.setHmrManager(this.hmrManager);
-    }
-    return renderer;
-  }
-  /**
-   * Declares whether a component boundary targeting this integration should be
-   * deferred through the marker pipeline.
-   *
-   * The default implementation never defers. Integrations that require deferred
-   * subtree rendering should override this method and return `true` when their
-   * boundary must be resolved during the marker graph stage.
-   *
-   * @param input Boundary metadata for the current render pass.
-   * @returns `true` when the boundary should be deferred; otherwise `false`.
-   */
-  shouldDeferComponentBoundary(_input) {
-    return false;
-  }
-  async setup() {
-    if (this.integrationDependencies.length === 0) return;
-    if (!this.assetProcessingService) throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_ASSET_SERVICE);
-    this.resolvedIntegrationDependencies = await this.assetProcessingService.processDependencies(
-      this.integrationDependencies,
-      this.name
-    );
-    this.initializeRenderer();
-  }
-  async teardown() {
-  }
-}
-export {
-  INTEGRATION_PLUGIN_ERRORS,
-  IntegrationPlugin
-};

package/src/plugins/processor.d.ts

@@ -1,82 +0,0 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
-import type { EcoPagesAppConfig, IClientBridge } from '../internal-types';
-import type { AssetDefinition } from '../services/asset-processing-service';
-export declare const PROCESSOR_ERRORS: {
-    readonly CACHE_DIRECTORY_NOT_SET: "Cache directory not set in context";
-};
-export interface ProcessorWatchContext {
-    path: string;
-    bridge: IClientBridge;
-}
-export interface ProcessorWatchConfig {
-    paths: string[];
-    extensions?: string[];
-    onCreate?: (ctx: ProcessorWatchContext) => Promise<void>;
-    onChange?: (ctx: ProcessorWatchContext) => Promise<void>;
-    onDelete?: (ctx: ProcessorWatchContext) => Promise<void>;
-    onError?: (error: Error) => void;
-}
-export type ProcessorAssetKind = 'script' | 'stylesheet' | 'image';
-export type ProcessorExtensionPattern = string;
-export interface ProcessorAssetCapability {
-    kind: ProcessorAssetKind;
-    /**
-     * Supported patterns:
-     * - `*` (all extensions)
-     * - `.css` or `css`
-     * - `*.css`
-     * - `*.{css,scss,sass}`
-     *
-     * Pattern matching is case-insensitive and trims surrounding spaces,
-     * including grouped values (e.g. `*.{ CSS, ScSs }`).
-     */
-    extensions?: ProcessorExtensionPattern[];
-}
-export interface ProcessorConfig<TOptions = Record<string, unknown>> {
-    name: string;
-    description?: string;
-    options?: TOptions;
-    watch?: ProcessorWatchConfig;
-    capabilities?: ProcessorAssetCapability[];
-}
-export interface ProcessorContext {
-    config: EcoPagesAppConfig;
-    rootDir: string;
-    srcDir: string;
-    distDir: string;
-    cache?: string;
-}
-/**
- * Interface for processor build plugins
- * This is used to pass plugins to the build process directly from the processor
- * For instance it can become very handy when dealing with virtual modules that needs to be recognized by the bundler
- * i.e. @ecopages/image-processor
- */
-export declare abstract class Processor<TOptions = Record<string, unknown>> {
-    readonly name: string;
-    protected dependencies: AssetDefinition[];
-    protected context?: ProcessorContext;
-    protected options?: TOptions;
-    protected watchConfig?: ProcessorWatchConfig;
-    protected capabilities: ProcessorAssetCapability[];
-    /** Plugins that are only used during the build process */
-    abstract buildPlugins?: EcoBuildPlugin[];
-    /** Plugins that are used during runtime for file processing */
-    abstract plugins?: EcoBuildPlugin[];
-    constructor(config: ProcessorConfig<TOptions>);
-    setContext(appConfig: EcoPagesAppConfig): void;
-    abstract setup(): Promise<void>;
-    abstract teardown(): Promise<void>;
-    abstract process(input: unknown, filePath?: string): Promise<unknown>;
-    protected getCachePath(key: string): string;
-    protected readCache<T>(key: string): Promise<T | null>;
-    protected writeCache<T>(key: string, data: T): Promise<void>;
-    getWatchConfig(): ProcessorWatchConfig | undefined;
-    getDependencies(): AssetDefinition[];
-    getName(): string;
-    getAssetCapabilities(): ProcessorAssetCapability[];
-    matchesFileFilter(_filepath: string): boolean;
-    canProcessAsset(kind: ProcessorAssetKind, filepath?: string): boolean;
-    private matchesCapabilityExtensions;
-    private normalizeExtensionPattern;
-}

package/src/plugins/processor.js

@@ -1,122 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-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 = [];
-  constructor(config) {
-    this.name = config.name;
-    this.options = config.options;
-    this.watchConfig = config.watch;
-    this.capabilities = config.capabilities ?? [];
-  }
-  setContext(appConfig) {
-    const cachePath = resolveGeneratedPath("cache", {
-      root: appConfig.absolutePaths.distDir,
-      module: this.name
-    });
-    fileSystem.ensureDir(cachePath);
-    this.context = {
-      config: appConfig,
-      rootDir: appConfig.rootDir,
-      srcDir: appConfig.absolutePaths.srcDir,
-      distDir: appConfig.absolutePaths.distDir,
-      cache: cachePath
-    };
-  }
-  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
-};