@reliverse/build 2.2.7

package/dist/impl/assets.d.ts

@@ -0,0 +1,28 @@
+import type { AssetOptions, PackageInfo } from "./types.js";
+export interface AssetProcessor {
+    processAssets(pkg: PackageInfo, outputDir: string, options?: AssetOptions): Promise<void>;
+}
+export declare class DefaultAssetProcessor implements AssetProcessor {
+    processAssets(pkg: PackageInfo, outputDir: string, options?: AssetOptions): Promise<void>;
+    private copyPublicAssets;
+    private copyAdditionalFiles;
+    private copyDirectory;
+    private optimizeImages;
+}
+export declare class CSSProcessor {
+    processCSS(_pkg: PackageInfo, outputDir: string, cssChunking?: boolean): Promise<void>;
+    private createCSSChunks;
+    private extractCommonPrefix;
+    private updateCSSReferences;
+}
+export declare class AssetManifest {
+    private manifest;
+    private reverseManifest;
+    addAsset(originalPath: string, hashedPath: string): void;
+    getAssetPath(originalPath: string): string;
+    getOriginalPath(hashedPath: string): string;
+    writeManifest(outputDir: string): Promise<void>;
+    loadManifest(outputDir: string): Promise<void>;
+}
+export declare function processAssetsForPackage(pkg: PackageInfo, outputDir: string, options?: AssetOptions): Promise<void>;
+export declare function processCSSForPackage(pkg: PackageInfo, outputDir: string, cssChunking?: boolean): Promise<void>;

package/dist/impl/assets.js

@@ -0,0 +1,188 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { relinka } from "@reliverse/relinka";
+export class DefaultAssetProcessor {
+  async processAssets(pkg, outputDir, options = {}) {
+    const {
+      publicPath = "/",
+      copyFiles = [],
+      imageOptimization = false
+    } = options;
+    if (pkg.hasPublicDir) {
+      await this.copyPublicAssets(pkg, outputDir, publicPath);
+    }
+    if (copyFiles.length > 0) {
+      await this.copyAdditionalFiles(pkg, outputDir, copyFiles, publicPath);
+    }
+    if (imageOptimization) {
+      await this.optimizeImages(pkg, outputDir);
+    }
+  }
+  async copyPublicAssets(pkg, outputDir, publicPath) {
+    const publicDir = join(pkg.path, "public");
+    if (!existsSync(publicDir)) {
+      return;
+    }
+    const publicOutputDir = join(outputDir, publicPath.replace(/^\//, ""));
+    await this.copyDirectory(publicDir, publicOutputDir);
+    await relinka.info(`\u{1F4C1} Copied public assets to ${publicOutputDir}`);
+  }
+  async copyAdditionalFiles(pkg, outputDir, copyFiles, publicPath) {
+    for (const filePattern of copyFiles) {
+      const sourcePath = resolve(pkg.path, filePattern);
+      if (existsSync(sourcePath)) {
+        const fileName = basename(sourcePath);
+        const destPath = join(
+          outputDir,
+          publicPath.replace(/^\//, ""),
+          fileName
+        );
+        mkdirSync(dirname(destPath), { recursive: true });
+        copyFileSync(sourcePath, destPath);
+        await relinka.info(`\u{1F4C4} Copied ${filePattern} to ${destPath}`);
+      }
+    }
+  }
+  async copyDirectory(src, dest) {
+    if (!existsSync(dest)) {
+      mkdirSync(dest, { recursive: true });
+    }
+    const glob = new Bun.Glob("**/*");
+    const files = Array.from(glob.scanSync({ cwd: src, onlyFiles: true }));
+    for (const file of files) {
+      const srcPath = join(src, file);
+      const destPath = join(dest, file);
+      mkdirSync(dirname(destPath), { recursive: true });
+      copyFileSync(srcPath, destPath);
+    }
+  }
+  async optimizeImages(_pkg, _outputDir) {
+    await relinka.info("\u{1F5BC}\uFE0F  Image optimization is not yet implemented");
+  }
+}
+export class CSSProcessor {
+  async processCSS(_pkg, outputDir, cssChunking = false) {
+    if (!cssChunking) {
+      return;
+    }
+    const glob = new Bun.Glob("**/*.css");
+    const cssFiles = Array.from(
+      glob.scanSync({ cwd: outputDir, onlyFiles: true })
+    );
+    if (cssFiles.length === 0) {
+      return;
+    }
+    await relinka.info(
+      `\u{1F3A8} Processing ${cssFiles.length} CSS files for chunking`
+    );
+    try {
+      const cssContents = [];
+      for (const cssFile of cssFiles) {
+        const fullPath = join(outputDir, cssFile);
+        const content = readFileSync(fullPath, "utf-8");
+        cssContents.push({ file: cssFile, content });
+      }
+      const chunks = this.createCSSChunks(cssContents);
+      for (const [chunkName, content] of Object.entries(chunks)) {
+        const chunkPath = join(outputDir, `${chunkName}.css`);
+        writeFileSync(chunkPath, content, "utf-8");
+        await relinka.info(`   \u{1F4C4} Created CSS chunk: ${chunkName}.css`);
+      }
+      await this.updateCSSReferences(cssFiles, chunks, outputDir);
+    } catch (error) {
+      await relinka.warn(`CSS chunking failed: ${error}`);
+    }
+  }
+  createCSSChunks(cssContents) {
+    const chunks = {};
+    const commonStyles = /* @__PURE__ */ new Map();
+    for (const { content } of cssContents) {
+      const lines = content.split("\n");
+      const commonPrefix = this.extractCommonPrefix(lines);
+      if (!commonStyles.has(commonPrefix)) {
+        commonStyles.set(commonPrefix, []);
+      }
+      commonStyles.get(commonPrefix)?.push(content);
+    }
+    let chunkIndex = 0;
+    for (const [prefix, styles] of commonStyles) {
+      const chunkName = prefix ? `chunk-${prefix}` : `chunk-${chunkIndex}`;
+      chunks[chunkName] = styles.join("\n\n");
+      chunkIndex++;
+    }
+    return chunks;
+  }
+  extractCommonPrefix(lines) {
+    const selectors = lines.filter(
+      (line) => line.trim().startsWith(".") || line.trim().startsWith("#")
+    ).map((line) => line.trim().split(" ")[0]).filter(Boolean);
+    if (selectors.length === 0) return "";
+    const firstSelector = selectors[0];
+    if (!firstSelector) return "";
+    let commonPrefix = "";
+    for (let i = 0; i < firstSelector.length; i++) {
+      const char = firstSelector[i];
+      if (selectors.every((selector) => selector && selector[i] === char)) {
+        commonPrefix += char;
+      } else {
+        break;
+      }
+    }
+    return commonPrefix.replace(/[^a-zA-Z0-9-_]/g, "");
+  }
+  async updateCSSReferences(cssFiles, _chunks, _outputDir) {
+    await relinka.info(
+      `   \u{1F4DD} Would update ${cssFiles.length} CSS files to reference chunks`
+    );
+  }
+}
+export class AssetManifest {
+  manifest = {};
+  reverseManifest = {};
+  addAsset(originalPath, hashedPath) {
+    this.manifest[originalPath] = hashedPath;
+    this.reverseManifest[hashedPath] = originalPath;
+  }
+  getAssetPath(originalPath) {
+    return this.manifest[originalPath] || originalPath;
+  }
+  getOriginalPath(hashedPath) {
+    return this.reverseManifest[hashedPath] || hashedPath;
+  }
+  async writeManifest(outputDir) {
+    const manifestPath = join(outputDir, "asset-manifest.json");
+    const manifestData = {
+      files: this.manifest,
+      reverse: this.reverseManifest,
+      timestamp: Date.now()
+    };
+    writeFileSync(manifestPath, JSON.stringify(manifestData, null, 2));
+    await relinka.info(`\u{1F4CB} Asset manifest written to ${manifestPath}`);
+  }
+  async loadManifest(outputDir) {
+    const manifestPath = join(outputDir, "asset-manifest.json");
+    if (existsSync(manifestPath)) {
+      try {
+        const manifestData = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        this.manifest = manifestData.files || {};
+        this.reverseManifest = manifestData.reverse || {};
+      } catch (error) {
+        await relinka.warn(`Failed to load asset manifest: ${error}`);
+      }
+    }
+  }
+}
+export async function processAssetsForPackage(pkg, outputDir, options = {}) {
+  const processor = new DefaultAssetProcessor();
+  await processor.processAssets(pkg, outputDir, options);
+}
+export async function processCSSForPackage(pkg, outputDir, cssChunking = false) {
+  const processor = new CSSProcessor();
+  await processor.processCSS(pkg, outputDir, cssChunking);
+}

package/dist/impl/cache.d.ts

@@ -0,0 +1,25 @@
+import type { BuildOptions, CacheEntry, CacheOptions, PackageInfo } from "./types.js";
+export declare class BuildCache {
+    private options;
+    private dependencyTracker;
+    private hits;
+    private misses;
+    constructor(options?: Partial<CacheOptions>);
+    ensureCacheDirectory(): void;
+    private getCacheKey;
+    private getCacheFilePath;
+    private getSourceHash;
+    get(pkg: PackageInfo, options: BuildOptions): Promise<CacheEntry | null>;
+    set(pkg: PackageInfo, options: BuildOptions, result: {
+        buildTime: number;
+        bundleSize: number;
+        outputFiles: string[];
+    }): Promise<void>;
+    delete(key: string): void;
+    clear(): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+}

package/dist/impl/cache.js

@@ -0,0 +1,209 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DependencyTracker } from "./dependency-tracker.js";
+const DEFAULT_CACHE_DIR = join(".reliverse", "dler", "cache", "build");
+const DEFAULT_TTL = 24 * 60 * 60 * 1e3;
+export class BuildCache {
+  options;
+  dependencyTracker;
+  hits = 0;
+  misses = 0;
+  constructor(options = {}) {
+    const homeDir = homedir();
+    const cacheDir = options.directory ?? join(homeDir, DEFAULT_CACHE_DIR);
+    this.options = {
+      enabled: options.enabled ?? true,
+      directory: cacheDir,
+      ttl: options.ttl ?? DEFAULT_TTL
+    };
+    this.dependencyTracker = new DependencyTracker();
+    if (this.options.enabled) {
+      this.ensureCacheDirectory();
+    }
+  }
+  ensureCacheDirectory() {
+    if (existsSync(this.options.directory)) {
+      return;
+    }
+    mkdirSync(this.options.directory, { recursive: true });
+  }
+  getCacheKey(pkg, options) {
+    const buildConfig = {
+      entryPoints: pkg.entryPoints,
+      outputDir: pkg.outputDir,
+      target: options.target,
+      format: options.format,
+      minify: options.minify,
+      sourcemap: options.sourcemap,
+      splitting: options.splitting,
+      external: options.external,
+      bytecode: options.bytecode,
+      drop: options.drop,
+      packages: options.packages,
+      publicPath: options.publicPath,
+      root: options.root,
+      define: options.define,
+      naming: options.naming,
+      env: options.env,
+      banner: options.banner,
+      footer: options.footer,
+      conditions: options.conditions,
+      loader: options.loader,
+      ignoreDCEAnnotations: options.ignoreDCEAnnotations,
+      emitDCEAnnotations: options.emitDCEAnnotations
+    };
+    const configString = JSON.stringify(
+      buildConfig,
+      Object.keys(buildConfig).sort()
+    );
+    const configHash = createHash("sha256").update(configString).digest("hex");
+    const projectHash = createHash("sha256").update(pkg.path).digest("hex").substring(0, 8);
+    return `${pkg.name}-${projectHash}-${configHash}`;
+  }
+  getCacheFilePath(key) {
+    return join(this.options.directory, `${key}.json`);
+  }
+  async getSourceHash(pkg) {
+    const hashes = [];
+    await this.dependencyTracker.trackDependencies(pkg.entryPoints);
+    const graph = this.dependencyTracker.getGraph();
+    for (const filePath of Object.keys(graph)) {
+      const fileHash = this.dependencyTracker.getFileHash(filePath);
+      if (fileHash) {
+        hashes.push(fileHash);
+      }
+    }
+    const packageJsonPath = join(pkg.path, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const content = readFileSync(packageJsonPath, "utf-8");
+      const hash = createHash("sha256").update(content).digest("hex");
+      hashes.push(hash);
+    }
+    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      const content = readFileSync(tsconfigPath, "utf-8");
+      const hash = createHash("sha256").update(content).digest("hex");
+      hashes.push(hash);
+    }
+    return createHash("sha256").update(hashes.join("")).digest("hex");
+  }
+  async get(pkg, options) {
+    if (!this.options.enabled) {
+      this.misses++;
+      return null;
+    }
+    try {
+      const key = this.getCacheKey(pkg, options);
+      const cacheFilePath = this.getCacheFilePath(key);
+      if (!existsSync(cacheFilePath)) {
+        this.misses++;
+        return null;
+      }
+      const cacheData = JSON.parse(readFileSync(cacheFilePath, "utf-8"));
+      const entry = cacheData;
+      const now = Date.now();
+      if (now - entry.timestamp > this.options.ttl) {
+        this.delete(key);
+        this.misses++;
+        return null;
+      }
+      const currentSourceHash = await this.getSourceHash(pkg);
+      if (entry.hash !== currentSourceHash) {
+        this.delete(key);
+        this.misses++;
+        return null;
+      }
+      for (const outputFile of entry.outputFiles) {
+        if (!existsSync(outputFile)) {
+          this.delete(key);
+          this.misses++;
+          return null;
+        }
+      }
+      this.hits++;
+      return entry;
+    } catch (_error) {
+      this.misses++;
+      return null;
+    }
+  }
+  async set(pkg, options, result) {
+    if (!this.options.enabled) {
+      return;
+    }
+    try {
+      const key = this.getCacheKey(pkg, options);
+      const sourceHash = await this.getSourceHash(pkg);
+      const entry = {
+        hash: sourceHash,
+        timestamp: Date.now(),
+        buildTime: result.buildTime,
+        bundleSize: result.bundleSize,
+        outputFiles: result.outputFiles
+      };
+      const cacheFilePath = this.getCacheFilePath(key);
+      writeFileSync(cacheFilePath, JSON.stringify(entry, null, 2));
+    } catch (_error) {
+    }
+  }
+  delete(key) {
+    if (!this.options.enabled) {
+      return;
+    }
+    try {
+      const cacheFilePath = this.getCacheFilePath(key);
+      if (existsSync(cacheFilePath)) {
+        const fs = require("node:fs");
+        fs.unlinkSync(cacheFilePath);
+      }
+    } catch (_error) {
+    }
+  }
+  clear() {
+    if (!this.options.enabled) {
+      return;
+    }
+    try {
+      const fs = require("node:fs");
+      const path = require("node:path");
+      if (existsSync(this.options.directory)) {
+        const files = fs.readdirSync(this.options.directory);
+        for (const file of files) {
+          if (file.endsWith(".json")) {
+            fs.unlinkSync(path.join(this.options.directory, file));
+          }
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  getStats() {
+    if (!this.options.enabled) {
+      return { hits: 0, misses: 0, size: 0 };
+    }
+    try {
+      const fs = require("node:fs");
+      const path = require("node:path");
+      if (!existsSync(this.options.directory)) {
+        return { hits: this.hits, misses: this.misses, size: 0 };
+      }
+      const files = fs.readdirSync(this.options.directory);
+      const jsonFiles = files.filter((file) => file.endsWith(".json"));
+      let totalSize = 0;
+      for (const file of jsonFiles) {
+        const filePath = path.join(this.options.directory, file);
+        const stats = fs.statSync(filePath);
+        totalSize += stats.size;
+      }
+      return {
+        hits: this.hits,
+        misses: this.misses,
+        size: totalSize
+      };
+    } catch (_error) {
+      return { hits: this.hits, misses: this.misses, size: 0 };
+    }
+  }
+}

package/dist/impl/constants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Default debounce time for file watching rebuilds (in milliseconds)
+ */
+export declare const DEFAULT_DEBOUNCE_MS = 300;
+/**
+ * Default concurrency for parallel package builds
+ */
+export declare const DEFAULT_CONCURRENCY = 5;
+/**
+ * Default dev server port
+ */
+export declare const DEFAULT_DEV_SERVER_PORT = 3000;
+/**
+ * Default dev server host
+ */
+export declare const DEFAULT_DEV_SERVER_HOST = "localhost";
+/**
+ * Always ignored packages (regardless of user configuration)
+ */
+export declare const ALWAYS_IGNORED_PACKAGES: string[];
+/**
+ * Common frontend HTML file patterns
+ */
+export declare const FRONTEND_HTML_PATTERNS: readonly ["index.html", "public/index.html", "src/index.html", "app.html", "public/app.html"];
+/**
+ * Common JavaScript/TypeScript entry point patterns
+ */
+export declare const JS_ENTRY_PATTERNS: readonly ["src/main.ts", "src/main.js", "src/index.ts", "src/index.js", "main.ts", "main.js", "index.ts", "index.js"];
+/**
+ * Common library entry point patterns
+ */
+export declare const LIBRARY_ENTRY_PATTERNS: readonly ["src/index.ts", "src/mod.ts", "index.ts", "src/index.js", "src/mod.js", "index.js"];
+/**
+ * Common Go project directories
+ */
+export declare const GO_PROJECT_DIRS: readonly ["cmd", "internal", "pkg", "prompts"];
+/**
+ * Frontend framework package names
+ */
+export declare const FRONTEND_FRAMEWORKS: readonly ["react", "preact", "solid-js", "lit", "alpinejs"];
+/**
+ * Default ignore patterns for file watching
+ */
+export declare const DEFAULT_IGNORE_PATTERNS: readonly ["node_modules/**", "dist/**", ".git/**", "**/*.log", "**/.DS_Store"];

package/dist/impl/constants.js

@@ -0,0 +1,45 @@
+export const DEFAULT_DEBOUNCE_MS = 300;
+export const DEFAULT_CONCURRENCY = 5;
+export const DEFAULT_DEV_SERVER_PORT = 3e3;
+export const DEFAULT_DEV_SERVER_HOST = "localhost";
+export const ALWAYS_IGNORED_PACKAGES = ["@reliverse/dler-v1"];
+export const FRONTEND_HTML_PATTERNS = [
+  "index.html",
+  "public/index.html",
+  "src/index.html",
+  "app.html",
+  "public/app.html"
+];
+export const JS_ENTRY_PATTERNS = [
+  "src/main.ts",
+  "src/main.js",
+  "src/index.ts",
+  "src/index.js",
+  "main.ts",
+  "main.js",
+  "index.ts",
+  "index.js"
+];
+export const LIBRARY_ENTRY_PATTERNS = [
+  "src/index.ts",
+  "src/mod.ts",
+  "index.ts",
+  "src/index.js",
+  "src/mod.js",
+  "index.js"
+];
+export const GO_PROJECT_DIRS = ["cmd", "internal", "pkg", "prompts"];
+export const FRONTEND_FRAMEWORKS = [
+  "react",
+  "preact",
+  "solid-js",
+  "lit",
+  "alpinejs"
+];
+export const DEFAULT_IGNORE_PATTERNS = [
+  "node_modules/**",
+  "dist/**",
+  ".git/**",
+  "**/*.log",
+  "**/.DS_Store"
+];

package/dist/impl/debug.d.ts

@@ -0,0 +1,30 @@
+import type { BuildOptions, BuildResult, BuildSummary, PackageInfo } from "./types.js";
+export interface DebugInfo {
+    configSource: "cli" | "reliverse" | "default";
+    configPath?: string;
+    resolvedOptions: BuildOptions;
+    packageCount: number;
+    entryPoints: string[];
+    buildTime: number;
+    bundleSize: number;
+    cacheHits: number;
+    errors: string[];
+    warnings: string[];
+}
+export declare class DebugLogger {
+    private enabled;
+    private startTime;
+    constructor(enabled?: boolean);
+    start(): void;
+    logConfigResolution(pkg: PackageInfo, configSource: string, configPath?: string): void;
+    logBuildOptions(options: BuildOptions, pkg: PackageInfo): void;
+    logEntryPoints(pkg: PackageInfo): void;
+    logBuildStats(summary: BuildSummary): void;
+    logPackageResult(result: BuildResult): void;
+    logDependencyGraph(pkg: PackageInfo, dependencies: string[]): void;
+    logCacheInfo(pkg: PackageInfo, cacheHit: boolean, cacheKey?: string): void;
+    logFileWatching(pkg: PackageInfo, watchedFiles: string[]): void;
+    logAssetProcessing(pkg: PackageInfo, assets: string[]): void;
+    logError(error: Error, context?: string): void;
+}
+export declare function createDebugLogger(options: BuildOptions): DebugLogger;