okno 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/plugin-DmiwHDt_.js

@@ -0,0 +1,459 @@
+import { extname as z, join as w, dirname as B, relative as N, sep as L, resolve as m } from "node:path";
+import { existsSync as E, readFileSync as U, mkdirSync as I, writeFileSync as R, cpSync as Y } from "node:fs";
+import { execSync as Q } from "node:child_process";
+import { fileURLToPath as Z } from "node:url";
+import { i as x, g as q, s as v, b as tt, a as et, c as ot, e as nt, d as rt, f as it, h as M, j as $, k as st } from "./dispatch-C34WXMSB.js";
+import { simpleGit as H } from "simple-git";
+import "./acorn-CZBJD705.js";
+function A(n, i, e) {
+  n.statusCode = i, n.setHeader("Content-Type", "application/json"), n.setHeader("Cache-Control", "no-store"), n.end(JSON.stringify(e));
+}
+function at(n) {
+  return new Promise((i) => {
+    let e = "";
+    n.on("data", (t) => e += t), n.on("end", () => {
+      try {
+        i(e ? JSON.parse(e) : {});
+      } catch {
+        i({});
+      }
+    }), n.on("error", () => i({}));
+  });
+}
+function lt(n) {
+  return new Promise((i, e) => {
+    const t = [];
+    n.on("data", (a) => t.push(a)), n.on("end", () => i(Buffer.concat(t))), n.on("error", e);
+  });
+}
+function ct(n, i) {
+  if (i) {
+    for (const e of new Set(i.modules)) {
+      const t = n.moduleGraph.getModuleById("\0okno:" + e);
+      t && n.moduleGraph.invalidateModule(t);
+    }
+    for (const e of new Set(i.files))
+      n.moduleGraph.getModulesByFile(e)?.forEach((t) => n.moduleGraph.invalidateModule(t));
+  }
+}
+function ut(n, i) {
+  n.middlewares.use(async (e, t, a) => {
+    if (!e.url?.startsWith("/__okno/api/")) return a();
+    const h = e.url.slice(12).split("?")[0], o = {
+      method: e.method || "GET",
+      route: h,
+      json: () => at(e),
+      binary: () => lt(e),
+      header: (r) => {
+        const s = e.headers[r];
+        return Array.isArray(s) ? s[0] : s;
+      }
+    };
+    try {
+      const r = await x(i, o);
+      if (!r) return a();
+      ct(n, r.invalidation), A(t, r.status, r.body);
+    } catch (r) {
+      A(t, 500, { error: r instanceof Error ? r.message : String(r) });
+    }
+  });
+}
+function dt(n, i) {
+  let e;
+  try {
+    e = decodeURIComponent(i);
+  } catch {
+    return null;
+  }
+  if (!e || e.includes("\0")) return null;
+  const t = m(n, "files"), a = m(t, e);
+  return a === t || !a.startsWith(t + L) ? null : a;
+}
+const P = "okno", ft = {
+  ".webp": "image/webp",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogg": "video/ogg",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".flac": "audio/flac",
+  ".pdf": "application/pdf",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf"
+};
+function pt(n, i) {
+  ut(n, i), n.middlewares.use((e, t, a) => {
+    if (e.method !== "GET" || !e.url?.startsWith("/okno/files/")) return a();
+    const h = e.url.slice(12).split("?")[0];
+    if (!h) return a();
+    const o = dt(i, h);
+    if (!o)
+      return t.statusCode = 403, t.end("Forbidden");
+    if (!E(o))
+      return t.statusCode = 404, t.end("Not found");
+    const r = z(o).toLowerCase();
+    t.setHeader("Content-Type", ft[r] || "application/octet-stream"), t.setHeader("Cache-Control", "public, max-age=3600"), t.end(U(o));
+  }), n.middlewares.use(async (e, t, a) => {
+    if (!e.url?.startsWith("/__okno/")) return a();
+    const h = e.url.slice(8);
+    t.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate"), t.setHeader("Pragma", "no-cache"), t.setHeader("Expires", "0");
+    try {
+      if (e.method === "GET" && h === "repo") {
+        t.setHeader("Content-Type", "application/json");
+        try {
+          const o = H(n.config.root), r = (await o.remote(["get-url", "origin"]))?.toString().trim(), s = (await o.revparse(["--abbrev-ref", "HEAD"])).trim(), { owner: p, repo: l } = gt(r);
+          return t.end(
+            JSON.stringify({ ok: !0, owner: p, repo: l, branch: s || null, remote: r || null })
+          );
+        } catch (o) {
+          return t.end(JSON.stringify({ ok: !1, error: String(o) }));
+        }
+      }
+      if (e.method === "POST" && h.startsWith("mirror")) {
+        const r = new URL(e.url, "http://localhost").searchParams.get("path");
+        if (!r || r.includes("..") || !r.startsWith("files/"))
+          return t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "Invalid path" }));
+        const s = w(i, r);
+        if (E(s))
+          return t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, skipped: !0 }));
+        const p = await mt(e);
+        return I(B(s), { recursive: !0 }), R(s, p), t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, written: r, bytes: p.length }));
+      }
+      if (e.method === "POST" && h === "sync") {
+        const r = (await ht(e))?.path;
+        if (r) {
+          if (r.includes("..") || r.includes("\0"))
+            return t.statusCode = 400, t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ error: "Invalid path" }));
+          const u = w(i, r);
+          try {
+            const c = H(i);
+            await c.fetch("origin", P);
+            const g = (await c.revparse(["--show-toplevel"])).trim(), f = N(g, u).split(L).join("/"), y = await c.show([`origin/${P}:${f}`]);
+            I(B(u), { recursive: !0 }), R(u, y);
+          } catch (c) {
+            const g = c instanceof Error ? c.message : String(c);
+            console.warn(
+              `[okno] sync: could not materialize ${r} from origin/${P} — ${g.split(`
+`)[0]}`
+            );
+          }
+          return F(n, r, u), t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, invalidated: r }));
+        }
+        const s = H(i), p = await s.revparse(["--show-toplevel"]), l = N(p.trim(), i);
+        try {
+          const u = await s.pull();
+          for (const c of u.files)
+            if (c.startsWith(`${l}/`)) {
+              const g = c.slice(`${l}/`.length), f = w(i, g);
+              F(n, g, f);
+            }
+          return t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, files: u.files }));
+        } catch (u) {
+          const c = u instanceof Error ? u.message : String(u);
+          return console.warn(`[okno] sync: git pull skipped — ${c.split(`
+`)[0]}`), t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({ ok: !0, pullSkipped: !0, reason: c }));
+        }
+      }
+      a();
+    } catch (o) {
+      t.statusCode = 500, t.end(JSON.stringify({ error: String(o) }));
+    }
+  });
+}
+function gt(n) {
+  if (!n) return { owner: null, repo: null };
+  const i = n.match(/github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  return i ? { owner: i[1], repo: i[2] } : { owner: null, repo: null };
+}
+function mt(n) {
+  return new Promise((i, e) => {
+    const t = [];
+    n.on("data", (a) => t.push(a)), n.on("end", () => i(Buffer.concat(t))), n.on("error", e);
+  });
+}
+function ht(n) {
+  return new Promise((i) => {
+    let e = "";
+    n.on("data", (t) => {
+      e += t;
+    }), n.on("end", () => {
+      try {
+        i(e ? JSON.parse(e) : null);
+      } catch {
+        i(null);
+      }
+    }), n.on("error", () => i(null));
+  });
+}
+function F(n, i, e) {
+  const t = "\0okno:";
+  let a;
+  if (i.startsWith("pages/") ? a = t + "pages" : i.startsWith("collections/") ? a = t + "collections" : i.startsWith("globals/") && (a = t + "globals"), a) {
+    const h = n.moduleGraph.getModuleById(a);
+    h && n.moduleGraph.invalidateModule(h);
+    const o = n.moduleGraph.getModulesByFile(e);
+    o && o.forEach((r) => {
+      n.moduleGraph.invalidateModule(r);
+    });
+  }
+}
+function yt(n, i) {
+  const e = (n.split("?")[0] ?? "").replace(/\\/g, "/"), t = i.replace(/\\/g, "/");
+  return e === t || e.startsWith(t + "/");
+}
+function wt(n, i) {
+  for (const [e, t] of Object.entries(i)) {
+    if (n === e) return t;
+    if (n.startsWith(e + "/")) return t + n.slice(e.length);
+  }
+  return null;
+}
+const bt = "okno:", _ = "\0okno:", St = /* @__PURE__ */ new Set(["pages", "collections", "globals", "locales", "strings", "content"]), K = B(Z(import.meta.url)), _t = JSON.parse(U(m(K, "../package.json"), "utf-8")).version, D = q(), b = m(K, "../editor"), T = m(b, "index.ts"), kt = E(T), Ot = {
+  "@modules": m(b, "modules"),
+  "@lib": m(b, "lib"),
+  "@logger": m(b, "lib/logger.svelte.ts"),
+  "@utils": m(b, "lib/utils.ts"),
+  "@/types": m(b, "lib/types.ts"),
+  "@styles": m(b, "styles"),
+  "@components": m(b, "components"),
+  "@assets": m(b, "assets"),
+  "@pages": m(b, "pages"),
+  "@controllers": m(b, "controllers")
+};
+function vt() {
+  try {
+    const n = (a) => Q(a, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim(), e = n("git remote get-url origin").match(/github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+    if (!e) return null;
+    const t = n("git rev-parse --abbrev-ref HEAD") || "main";
+    return `${e[1]}/${e[2]}@${t}`;
+  } catch {
+    return null;
+  }
+}
+function It(n = {}) {
+  const i = n.dir ?? "okno";
+  let e, t, a = !1, h = !1;
+  return n.isEditor, {
+    name: "okno",
+    enforce: "pre",
+    config(o, r) {
+      const s = r.command === "serve";
+      return h = r.command === "build", a = s && kt, {
+        define: {
+          __OKNO_API_URL__: JSON.stringify(n.apiUrl ?? "https://api.okno.build"),
+          __OKNO_VERSION__: JSON.stringify(_t),
+          // True when the consumer is running `vite dev` / `astro dev` /
+          // `sveltekit dev` — anything that serves locally. Replaced at
+          // consumer build time so the prebuilt editor bundle can honor
+          // the consumer's actual environment.
+          __OKNO_IS_DEV__: JSON.stringify(s),
+          // Public demo build: editor boots login-less, reads a static
+          // `okno-demo.json` snapshot, no-ops writes. See docs/demo-mode.md.
+          __OKNO_DEMO__: JSON.stringify(n.demo ?? !1),
+          // Repo identity (`owner/repo@branch`) baked from the app's git
+          // origin at the consumer's build time, so the deployed editor
+          // auto-targets its repo with no picker. null outside a git
+          // checkout → editor falls back to the picker. Dev ignores it
+          // (runtime /__okno/repo derivation is more current).
+          __OKNO_REPO__: JSON.stringify(vt())
+        },
+        // Source mode (monorepo dev only): skip prebundling so saves to
+        // `package/editor/**` propagate via HMR instead of needing
+        // `bun run build:pkg`. The editor's internal @-aliases are NOT exposed
+        // as a global `resolve.alias` here — that shadowed a consumer's own
+        // identically-named tsconfig aliases (`@components`, `@lib`, …). They
+        // are instead resolved per-importer in `resolveId`, scoped to imports
+        // originating inside the editor source tree. See editor-aliases.ts.
+        ...a && {
+          optimizeDeps: { exclude: ["okno", "okno/editor"] }
+        },
+        server: {
+          watch: {
+            // Only ignore binary assets and editor-only metadata. Page/
+            // collection/global .ts files SHOULD trigger Vite HMR — that's
+            // how users see updates when they `git pull` content from the
+            // drafts branch into their working tree. (Previously this list
+            // also blocked pages/collections/globals because in DEV_MODE
+            // the backend mirrored saves to disk, causing spurious full
+            // reloads. In production-mode the backend never touches local
+            // FS so blocking those is pure harm — pulls go unseen.)
+            ignored: [`**/${i}/files/**`, `**/${i}/.okno-tree.json`]
+          },
+          // Source mode: the editor loads via a dynamic `import("okno/editor")`
+          // from a separate package over `@fs`, so Vite's startup dep scan
+          // never crawls it — its transitive deps (bits-ui, tiptap, runed…)
+          // are discovered lazily on first import, triggering a mid-session
+          // re-optimize that 404s the now-stale prebundled chunks. Warming the
+          // editor entry forces that crawl at startup, so those deps land in
+          // the first optimize pass and never re-bundle under the user.
+          ...a && {
+            warmup: { clientFiles: [T] }
+          }
+        }
+      };
+    },
+    configResolved(o) {
+      e = o.root, t = m(e, i);
+    },
+    async buildStart() {
+      if (E(t) && (await M(t, e), n.demo)) {
+        const o = w(e, "public");
+        E(o) || I(o, { recursive: !0 }), R(
+          w(o, "okno-demo.json"),
+          JSON.stringify(st(t))
+        );
+        const r = w(t, "files");
+        E(r) && Y(r, w(o, "okno", "files"), {
+          recursive: !0,
+          filter: (s) => !s.endsWith(".okno-tree.json")
+        });
+      }
+    },
+    configureServer(o) {
+      pt(o, t);
+      const r = (p) => {
+        const l = N(t, p);
+        if (l.startsWith("..") || !l.endsWith(".ts")) return;
+        const u = l.split(/[\\/]/)[0];
+        if (u !== "pages" && u !== "collections" && u !== "globals") return;
+        const c = o.moduleGraph.getModuleById(_ + u);
+        c && o.moduleGraph.invalidateModule(c), o.moduleGraph.getModulesByFile(p)?.forEach((g) => o.moduleGraph.invalidateModule(g)), !$(p) && o.ws.send({ type: "full-reload" });
+      };
+      o.watcher.on("add", r), o.watcher.on("unlink", r), o.middlewares.use("/__okno/imports", async (p, l, u) => {
+        if (p.method !== "GET") return u();
+        try {
+          const [c, g, f] = await Promise.all([
+            v(e, "pages"),
+            v(e, "globals"),
+            v(e, "collections")
+          ]);
+          l.setHeader("Content-Type", "application/json"), l.setHeader("Cache-Control", "no-store"), l.end(JSON.stringify({
+            pages: Array.from(c),
+            globals: Array.from(g),
+            collections: Array.from(f)
+          }));
+        } catch (c) {
+          u(c);
+        }
+      });
+      const s = "/__okno_bootstrap.js";
+      o.middlewares.use(s, async (p, l, u) => {
+        try {
+          const c = await o.transformRequest("\0okno:bootstrap");
+          if (!c) {
+            l.statusCode = 500, l.end("okno bootstrap transform failed");
+            return;
+          }
+          l.setHeader("content-type", "text/javascript"), l.end(c.code);
+        } catch (c) {
+          u(c);
+        }
+      }), o.middlewares.use((p, l, u) => {
+        const c = "<script>window.__oknoDev=true<\/script>", g = n.demo ? "<script>window.__oknoDemo=true<\/script>" : "", f = `${c}${g}<script type="module" src="${s}"><\/script>`, y = [];
+        let k = null;
+        const V = l.write.bind(l), j = l.end.bind(l), X = l.setHeader.bind(l), G = () => {
+          const d = l.getHeader("content-type");
+          return typeof d == "string" && d.includes("text/html");
+        }, W = (d, S) => Buffer.isBuffer(d) ? d : d instanceof Uint8Array ? Buffer.from(d.buffer, d.byteOffset, d.byteLength) : typeof d == "string" ? Buffer.from(d, S || "utf-8") : Buffer.from(String(d));
+        l.write = (d, S, ...C) => (k === null && (k = G()), k ? (d && y.push(W(d, typeof S == "string" ? S : void 0)), !0) : V(d, S, ...C)), l.end = (d, S, ...C) => {
+          if (k === null && (k = G()), !k) return j(d, S, ...C);
+          d && y.push(W(d, typeof S == "string" ? S : void 0));
+          let O = Buffer.concat(y).toString("utf-8");
+          O.includes(f) || (O = O.includes("</body>") ? O.replace("</body>", `${f}</body>`) : O + f);
+          const J = Buffer.from(O, "utf-8");
+          if (!l.headersSent)
+            try {
+              X("content-length", String(J.length));
+            } catch {
+            }
+          return j(J, ...C);
+        }, u();
+      });
+    },
+    async handleHotUpdate(o) {
+      const r = w(t, "schema.ts"), s = w(t, "users.json"), p = w(t, "permissions.ts"), l = w(t, "modules.d.ts");
+      if (o.file === r) {
+        await M(t, e);
+        for (const f of ["pages", "collections", "globals", "locales", "content", "strings"]) {
+          const y = o.server.moduleGraph.getModuleById(_ + f);
+          y && o.server.moduleGraph.invalidateModule(y);
+        }
+        return [];
+      }
+      if (o.file === s || o.file === p || o.file === l)
+        return [];
+      const u = w(t, "strings.ts"), c = N(w(t, "strings"), o.file);
+      if (o.file === u || !c.startsWith("..") && c.endsWith(".ts")) {
+        await M(t, e);
+        for (const f of ["strings", "content"]) {
+          const y = o.server.moduleGraph.getModuleById(_ + f);
+          y && o.server.moduleGraph.invalidateModule(y);
+        }
+      }
+      const g = N(t, o.file);
+      if (!g.startsWith("..") && g.endsWith(".ts")) {
+        const f = g.split(/[\\/]/)[0];
+        if ((f === "pages" || f === "collections" || f === "globals") && $(o.file)) {
+          const y = o.server.moduleGraph.getModuleById(_ + f);
+          return y && o.server.moduleGraph.invalidateModule(y), [];
+        }
+      }
+    },
+    async resolveId(o, r) {
+      if (o.startsWith(bt))
+        return "\0" + o;
+      if (o.startsWith("okno/")) {
+        const s = o.slice(5);
+        if (St.has(s)) return _ + s;
+      }
+      if (a && o === "okno/editor")
+        return T;
+      if (a && r && yt(r, b)) {
+        const s = wt(o, Ot);
+        if (s)
+          return (await this.resolve(s, r, { skipSelf: !0 }))?.id;
+      }
+    },
+    async load(o) {
+      if (!o.startsWith(_)) return;
+      const r = o.slice(_.length);
+      if (r === "runtime") {
+        if (!D)
+          throw new Error("okno: runtime/wrap.js missing — run `bun run build:pkg`");
+        return D;
+      }
+      if (r === "bootstrap")
+        return 'import("okno/editor")';
+      if (r === "pages") {
+        const s = await v(e, "pages");
+        return await tt(t, s);
+      }
+      if (r === "collections") {
+        const s = await v(e, "collections");
+        return await et(t, s, h);
+      }
+      if (r === "globals") {
+        const s = await v(e, "globals");
+        return await ot(t, s);
+      }
+      if (r === "locales")
+        return nt(t);
+      if (r === "strings")
+        return await rt(t);
+      if (r === "content")
+        return it();
+    }
+  };
+}
+export {
+  It as o
+};

package/dist/vite/index.js

@@ -1,4 +1,4 @@
-import { o as a } from "../plugin-DkXOrSVC.js";
+import { o as a } from "../plugin-DmiwHDt_.js";
 export {
   a as okno
 };

package/dist/vite/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAiFpD,wBAAgB,IAAI,CAAC,MAAM,GAAE,UAAe,GAAG,MAAM,CA+XpD"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AA+EpD,wBAAgB,IAAI,CAAC,MAAM,GAAE,UAAe,GAAG,MAAM,CAiYpD"}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "okno",
 	"description": "Git-backed CMS with live editing for any Vite framework",
 	"author": "Gabriel Uhlíř",
-	"version": "1.0.0-beta.13",
+	"version": "1.0.0-beta.14",
 	"homepage": "https://okno.build",
 	"type": "module",
 	"types": "./dist/index.d.ts",