alinea/dist/cli/Generate.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import "../chunks/chunk-U5RRZUYZ.js";

// src/cli/Generate.ts
import fs from "node:fs";
import { createRequire } from "node:module";
import path from "node:path";
import { compileConfig } from "./generate/CompileConfig.js";
import { copyStaticFiles } from "./generate/CopyStaticFiles.js";
import { fillCache } from "./generate/FillCache.js";
import { generateDashboard } from "./generate/GenerateDashboard.js";
import { loadCMS } from "./generate/LoadConfig.js";
import { LocalData } from "./generate/LocalData.js";
import { dirname } from "./util/Dirname.js";
import { findConfigFile } from "./util/FindConfigFile.js";
var __dirname = dirname(import.meta.url);
var require2 = createRequire(import.meta.url);
var alineaPackageDir = path.dirname(require2.resolve("alinea/package.json"));
function generatePackage(context, config) {
  const dashboard = config.dashboard;
  if (dashboard?.staticFile)
    return generateDashboard(
      context,
      dashboard.handlerUrl,
      dashboard.staticFile
    );
}
async function createDb() {
  const { default: sqlite } = await import("@alinea/sqlite-wasm");
  const { Database } = await sqlite();
  const { connect } = await import("../chunks/sql.js-OZNQGHQS.js");
  const db = new Database();
  const store = connect(db).toAsync();
  return [store, () => db.export()];
}
async function* generate(options) {
  const {
    wasmCache = false,
    cwd = process.cwd(),
    configFile,
    staticDir = path.join(__dirname, "static"),
    quiet = false,
    onAfterGenerate
  } = options;
  const configLocation = configFile ? path.join(path.resolve(cwd), configFile) : findConfigFile(cwd);
  if (!configLocation)
    throw new Error(`No config file specified`);
  const rootDir = path.resolve(cwd);
  const configDir = path.dirname(configLocation);
  const nodeModules = alineaPackageDir.includes("node_modules") ? path.join(alineaPackageDir, "..") : path.join(alineaPackageDir, "node_modules");
  const context = {
    wasmCache,
    rootDir,
    staticDir,
    quiet,
    configDir,
    configLocation,
    fix: options.fix || false,
    outDir: path.join(nodeModules, "@alinea/generated"),
    // path.join(rootDir, '.alinea'),
    watch: options.watch || false
  };
  const builds = compileConfig(context)[Symbol.asyncIterator]();
  let nextBuild = builds.next();
  let afterGenerateCalled = false;
  const [store, exportStore] = await createDb();
  await copyStaticFiles(context);
  while (true) {
    const { done } = await nextBuild;
    nextBuild = builds.next();
    try {
      const cms = await loadCMS(context.outDir);
      cms.exportStore(context.outDir, new Uint8Array());
      const fileData = new LocalData({
        config: cms.config,
        fs: fs.promises,
        rootDir,
        dashboardUrl: await options.dashboardUrl
      });
      for await (const db of fillCache(
        context,
        fileData,
        store,
        cms.config,
        nextBuild
      )) {
        yield { cms, db, localData: fileData };
        if (process.env.NODE_ENV === "development")
          fs.writeFileSync(
            path.join(context.outDir, "content.sqlite"),
            exportStore()
          );
        if (onAfterGenerate && !afterGenerateCalled) {
          afterGenerateCalled = true;
          onAfterGenerate();
        }
      }
      if (done) {
        await Promise.all([
          generatePackage(context, cms.config),
          cms.exportStore(context.outDir, exportStore())
        ]);
        break;
      }
    } catch (e) {
      console.error(e);
    }
  }
}
export {
  generate
};