opacacms 0.3.1 → 0.3.3

package/dist/chunk-r0ms5tk1.js

@@ -1,76 +0,0 @@
-import {
-  require_picocolors
-} from "./chunk-rwqwsanx.js";
-import {
-  Gt,
-  R,
-  Vt,
-  Wt
-} from "./chunk-ec4jhybj.js";
-import {
-  defineCommand
-} from "./chunk-1qm0m8r8.js";
-import {
-  __toESM
-} from "./chunk-6bywt602.js";
-
-// src/cli/commands/dev.ts
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import { resolve } from "node:path";
-var import_picocolors = __toESM(require_picocolors(), 1);
-var dev_default = defineCommand({
-  meta: {
-    name: "dev",
-    description: "Start the OpacaCMS development server"
-  },
-  args: {
-    entry: {
-      type: "string",
-      description: "Path to your entry point (default: index.ts)",
-      default: "index.ts"
-    }
-  },
-  async run({ args }) {
-    console.log();
-    Wt(import_picocolors.default.bgBlue(import_picocolors.default.white(" OpacaCMS Dev Server ")));
-    const entryPath = resolve(process.cwd(), args.entry);
-    if (!fs.existsSync(entryPath)) {
-      R.error(import_picocolors.default.red(`Entry file not found at ${entryPath}`));
-      R.info("Try specifying the entry file: opacacms dev --entry src/index.ts");
-      process.exit(1);
-    }
-    Vt(`Watching for changes...`, "Status");
-    const isD1 = fs.readFileSync(entryPath, "utf-8").includes("createCloudflareWorkersHandler");
-    let cmd = "bun";
-    let cmdArgs = ["run", "--watch", args.entry];
-    if (isD1) {
-      cmd = "bun";
-      cmdArgs = ["x", "wrangler", "dev", args.entry];
-    }
-    const child = spawn(cmd, cmdArgs, {
-      stdio: "inherit",
-      cwd: process.cwd(),
-      env: process.env
-    });
-    child.on("error", (err) => {
-      R.error(import_picocolors.default.red(`Failed to start server: ${err.message}`));
-    });
-    child.on("exit", (code) => {
-      if (code !== 0) {
-        R.warn(`Server exited with code ${code}`);
-      }
-      Gt("Goodbye!");
-      process.exit(code || 0);
-    });
-    process.on("SIGINT", () => {
-      child.kill("SIGINT");
-    });
-    process.on("SIGTERM", () => {
-      child.kill("SIGTERM");
-    });
-  }
-});
-export {
-  dev_default as default
-};

package/dist/chunk-rwqwsanx.js

@@ -1,75 +0,0 @@
-import {
-  __commonJS
-} from "./chunk-6bywt602.js";
-
-// ../../node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
-export { require_picocolors };

package/dist/chunk-x7bnzswh.js

@@ -1,174 +0,0 @@
-import"./chunk-6bywt602.js";
-
-// src/cli/core/mocks/r2-mock.ts
-import { Database } from "bun:sqlite";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-function createR2Mock(dbPath) {
-  let sqlite;
-  let blobsDir;
-  let finalDbPath;
-  const wranglerR2Dir = path.resolve(process.cwd(), ".wrangler/state/v3/r2/miniflare-R2BucketObject");
-  if (!dbPath && fs.existsSync(wranglerR2Dir)) {
-    const files = fs.readdirSync(wranglerR2Dir);
-    const sqliteFile = files.find((f) => f.endsWith(".sqlite"));
-    if (sqliteFile) {
-      finalDbPath = path.join(wranglerR2Dir, sqliteFile);
-      console.log(`[OpacaCMS] Using Wrangler R2 local state: ${sqliteFile}`);
-    }
-  }
-  if (!finalDbPath) {
-    if (!dbPath) {
-      finalDbPath = ":memory:";
-      console.log("[OpacaCMS] Using in-memory R2 mock");
-    } else {
-      const absolutePath = path.isAbsolute(dbPath) ? dbPath : path.resolve(process.cwd(), dbPath);
-      if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
-        finalDbPath = path.join(absolutePath, "mock-bucket.sqlite");
-      } else if (!absolutePath.endsWith(".sqlite")) {
-        finalDbPath = absolutePath.endsWith("/") ? path.join(absolutePath, "mock-bucket.sqlite") : absolutePath + ".sqlite";
-      } else {
-        finalDbPath = absolutePath;
-      }
-      console.log(`[OpacaCMS] Using local R2 mock: ${path.basename(finalDbPath)}`);
-    }
-  }
-  if (finalDbPath !== ":memory:") {
-    const dir = path.dirname(finalDbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    blobsDir = finalDbPath.replace(".sqlite", ".blobs");
-    if (!fs.existsSync(blobsDir)) {
-      fs.mkdirSync(blobsDir, { recursive: true });
-    }
-  } else {
-    blobsDir = path.join(fs.realpathSync("/tmp"), `opaca-blobs-${crypto.randomUUID()}`);
-  }
-  try {
-    sqlite = new Database(finalDbPath);
-  } catch (err) {
-    throw new Error(`Failed to open R2 mock database at ${finalDbPath}: ${err.message}`);
-  }
-  sqlite.exec(`
-    CREATE TABLE IF NOT EXISTS _mf_objects (
-      key TEXT PRIMARY KEY,
-      blob_id TEXT,
-      version TEXT,
-      size INTEGER,
-      etag TEXT,
-      uploaded INTEGER,
-      checksums TEXT,
-      http_metadata TEXT,
-      custom_metadata TEXT
-    )
-  `);
-  const getBlobPath = (blobId) => path.join(blobsDir, blobId);
-  return {
-    async put(key, value, options) {
-      const blobId = crypto.randomUUID();
-      const filePath = getBlobPath(blobId);
-      const buffer = value instanceof Uint8Array ? value : value instanceof ArrayBuffer ? new Uint8Array(value) : typeof value === "string" || value instanceof Buffer ? Buffer.from(value) : new Uint8Array(await value.arrayBuffer());
-      fs.writeFileSync(filePath, buffer);
-      const etag = crypto.createHash("md5").update(buffer).digest("hex");
-      const uploaded = Date.now();
-      const size = buffer.length;
-      const httpMetadataObj = {};
-      if (options?.httpMetadata?.contentType) {
-        httpMetadataObj.contentType = options.httpMetadata.contentType;
-      }
-      const customMetadataObj = { ...options?.customMetadata };
-      if (options?.customMetadata?.sourceUrl) {
-        customMetadataObj.sourceUrl = options.customMetadata.sourceUrl;
-      }
-      const httpMetadata = JSON.stringify(httpMetadataObj);
-      const customMetadata = JSON.stringify(customMetadataObj);
-      sqlite.prepare(`
-        INSERT OR REPLACE INTO _mf_objects 
-        (key, blob_id, version, size, etag, uploaded, checksums, http_metadata, custom_metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(key, blobId, "v1", size, etag, uploaded, "{}", httpMetadata, customMetadata);
-      return {
-        key,
-        size,
-        etag,
-        httpMetadata: options?.httpMetadata || {},
-        customMetadata: options?.customMetadata || {}
-      };
-    },
-    async get(key) {
-      const row = sqlite.prepare("SELECT * FROM _mf_objects WHERE key = ?").get(key);
-      if (!row)
-        return null;
-      const filePath = getBlobPath(row.blob_id);
-      if (!fs.existsSync(filePath))
-        return null;
-      const buffer = fs.readFileSync(filePath);
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(new Uint8Array(buffer));
-          controller.close();
-        }
-      });
-      return {
-        key: row.key,
-        size: row.size,
-        etag: row.etag,
-        uploaded: new Date(row.uploaded),
-        httpMetadata: JSON.parse(row.http_metadata || "{}"),
-        customMetadata: JSON.parse(row.custom_metadata || "{}"),
-        body: stream,
-        bodyUsed: false,
-        async arrayBuffer() {
-          return buffer.buffer;
-        },
-        async text() {
-          return buffer.toString();
-        },
-        async json() {
-          return JSON.parse(buffer.toString());
-        }
-      };
-    },
-    async head(key) {
-      const row = sqlite.prepare("SELECT key, size, etag, http_metadata, custom_metadata, uploaded FROM _mf_objects WHERE key = ?").get(key);
-      if (!row)
-        return null;
-      return {
-        key: row.key,
-        size: row.size,
-        etag: row.etag,
-        uploaded: new Date(row.uploaded),
-        httpMetadata: JSON.parse(row.http_metadata || "{}"),
-        customMetadata: JSON.parse(row.custom_metadata || "{}")
-      };
-    },
-    async delete(key) {
-      const row = sqlite.prepare("SELECT blob_id FROM _mf_objects WHERE key = ?").get(key);
-      if (row) {
-        const filePath = getBlobPath(row.blob_id);
-        if (fs.existsSync(filePath))
-          fs.unlinkSync(filePath);
-        sqlite.prepare("DELETE FROM _mf_objects WHERE key = ?").run(key);
-      }
-    },
-    async list() {
-      const rows = sqlite.prepare("SELECT * FROM _mf_objects").all();
-      return {
-        objects: rows.map((row) => ({
-          key: row.key,
-          size: row.size,
-          etag: row.etag,
-          uploaded: new Date(row.uploaded),
-          httpMetadata: JSON.parse(row.http_metadata || "{}"),
-          customMetadata: JSON.parse(row.custom_metadata || "{}")
-        })),
-        truncated: false
-      };
-    }
-  };
-}
-export {
-  createR2Mock
-};