okno 1.0.0-alpha.13 → 1.0.0-alpha.14

package/dist/boot.d.ts

@@ -0,0 +1,38 @@
+/**
+ * okno client boot — production editor delivery.
+ *
+ * In dev the okno Vite plugin injects the editor through dev-server middleware
+ * (`configureServer` in src/vite/plugin.ts). That middleware does not run in a
+ * production build, and on SSG frameworks (Astro et al.) the okno runtime is
+ * server-only — so a deployed page ships no editor at all. This module is the
+ * client-side entry that closes that gap: a page pulls it in (via a framework
+ * integration or a `<script>` in the layout) and it lazily boots the editor on
+ * demand.
+ *
+ * The ~1 MB editor bundle is loaded only when an editor signals intent —
+ * pressing `e`, or visiting with `?okno` / `#okno`. Public visitors download
+ * only this tiny gate. `import("okno/editor")` is a bare specifier the
+ * *consumer's* bundler resolves and code-splits at their build time (okno's own
+ * build keeps it external via rollup `external`), so the editor lands as its own
+ * chunk rather than inside this file.
+ */
+declare const __OKNO_IS_DEV__: boolean;
+declare const GATE_KEY = "e";
+declare const g: {
+    document?: Document;
+    location?: Location;
+    __okno_loaded?: boolean;
+    __okno_gate_installed?: boolean;
+    __okno_autostart?: "key" | "url" | false;
+};
+declare let loading: boolean;
+/** The editor sets `window.__okno_loaded` at the top of its entry module, so
+ *  this flips true the moment the bundle starts evaluating. */
+declare function editorPresent(): boolean;
+/** Don't hijack `e` while the visitor is typing in the host page. Mirrors the
+ *  editor's own focus check (modules/keys.svelte.ts), shadow DOM included. */
+declare function isTyping(): boolean;
+declare function bootEditor(reason: "key" | "url"): void;
+declare function urlRequestsEditor(): boolean;
+declare function install(): void;
+//# sourceMappingURL=boot.d.ts.map

package/dist/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../src/boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,CAAC,MAAM,eAAe,EAAE,OAAO,CAAA;AAEtC,QAAA,MAAM,QAAQ,MAAM,CAAA;AAEpB,QAAA,MAAM,CAAC,EAA4B;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,gBAAgB,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;CACxC,CAAA;AAED,QAAA,IAAI,OAAO,SAAQ,CAAA;AAEnB;+DAC+D;AAC/D,iBAAS,aAAa,IAAI,OAAO,CAEhC;AAED;8EAC8E;AAC9E,iBAAS,QAAQ,IAAI,OAAO,CAO3B;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAa/C;AAED,iBAAS,iBAAiB,IAAI,OAAO,CASpC;AAED,iBAAS,OAAO,IAAI,IAAI,CAgBvB"}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read the schema, scan content directories, and generate:
+ * - modules.d.ts (type declarations for okno:* virtual modules)
+ *
+ * `root` is the project root (parent of the okno dir) — we scan it for
+ * `import { x } from "okno:<kind>"` so names referenced before scaffolding
+ * still get a (placeholder) type, mirroring the runtime virtual modules.
+ */
+export declare function generateTypes(oknoDir: string, root: string): Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,iBAwGhE"}

package/dist/codegen/scan-imports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Walk the project root looking for `import { foo, bar } from "okno:<kind>"`
+ * statements and return the union of imported names. Used by both the runtime
+ * virtual modules and the type codegen to emit placeholder exports for content
+ * that doesn't exist yet, so a project can refer to `home.title` (and get types
+ * for it) before any schema is scaffolded.
+ */
+export declare function scanImports(root: string, kind: "pages" | "collections" | "globals"): Promise<Set<string>>;
+//# sourceMappingURL=scan-imports.d.ts.map

package/dist/codegen/scan-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-imports.d.ts","sourceRoot":"","sources":["../../src/codegen/scan-imports.ts"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,wBAAsB,WAAW,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,GACvC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA0CtB"}

package/dist/core/content-encode.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Canonical serializers: a content/schema object → its `.ts` source module.
+ *
+ * The byte format is a CONTRACT. The same logical content must encode
+ * identically on the live path (hosted backend → GitHub commit) and the dev
+ * path (local engine → disk write), or a publish round-trip shows phantom
+ * diffs. Keep this module dependency-free (pure string/JSON, no node/svelte) so
+ * either side can import it.
+ *
+ * SYNC: `backend/src/lib/encode.ts` is a byte-identical copy. The backend is a
+ * separate deployable and this monorepo has no cross-package source imports
+ * (same controlled-duplication pattern as this package's
+ * `editor/lib/parse-export-default.ts` ↔ the backend's `lib/parse.ts`). Any
+ * change here MUST be mirrored there, and vice versa.
+ */
+export interface Stamp {
+    date: string;
+    author: string;
+}
+/**
+ * A content entry (page / collection item / global) → `export default {...}`.
+ * Stamps `updated` from `now`/`author`, and `created` from the same stamp unless
+ * a prior `created` is passed through (preserved across edits).
+ *
+ * Key order — content fields, then `created`, then `updated` — is part of the
+ * byte contract. Do not reorder.
+ */
+export declare function encodeEntry(content: Record<string, unknown>, opts: {
+    now: string;
+    author: string;
+    created?: Stamp;
+}): string;
+/**
+ * The schema → `<header>export default {...} satisfies Schema`. `header`
+ * preserves the file's existing import/comment prelude (default: the canonical
+ * `import type { Schema } from "okno"`).
+ */
+export declare function encodeSchema(schema: Record<string, unknown>, header?: string): string;
+/**
+ * Bare `export default <json>` with no metadata — for scaffold seeds (a fresh
+ * page/global's default field values, or an empty `[]` collection).
+ */
+export declare function encodeRaw(value: unknown): string;
+//# sourceMappingURL=content-encode.d.ts.map

package/dist/core/content-encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-encode.d.ts","sourceRoot":"","sources":["../../src/core/content-encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,KAAK;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GACpD,MAAM,CAIR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,SAA2C,GAC/C,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEhD"}

package/dist/core/order.d.ts

@@ -0,0 +1,18 @@
+/**
+ * okno's manual collection ordering — the single source of truth shared by the
+ * build plugin (`okno:collections` iteration order) and the editor (collection
+ * table + reference lists). okno owns ONLY this manual order; any date/field
+ * sort is the dev's own `.sort()` in their template, right before `.map()`.
+ */
+/**
+ * Order `items` by an explicit slug list. Items whose slug appears in `order`
+ * come first, in that order; everything else keeps its original relative order
+ * after them (so items added outside the editor — not yet in `order` — still
+ * show up, just unsorted at the end). Pure and stable; never drops items.
+ */
+export declare function orderBySlugs<T>(items: T[], getSlug: (item: T) => string | undefined, order?: string[]): T[];
+/** Apply a create/delete to a slug-order list. Create prepends (newest-first);
+ *  delete drops the slug. Returns a new array; both are no-ops when redundant. */
+export declare function orderWithInsert(order: string[] | undefined, slug: string): string[];
+export declare function orderWithout(order: string[] | undefined, slug: string): string[];
+//# sourceMappingURL=order.d.ts.map

package/dist/core/order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../src/core/order.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,EACxC,KAAK,CAAC,EAAE,MAAM,EAAE,GACd,CAAC,EAAE,CAaL;AAED;kFACkF;AAClF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnF;AACD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhF"}

package/dist/core/parse.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parser for `export default { ... }` TypeScript content/schema files.
+ *
+ * We must NOT execute file content (`new Function` would be an RCE and corrupts
+ * any string containing `//`). Instead we parse the `export default` expression
+ * with acorn and walk the AST, accepting ONLY literal data; anything that would
+ * *evaluate* is rejected.
+ *
+ * SYNC: byte-for-byte the editor's `editor/lib/parse-export-default.ts` and the
+ * backend's `lib/parse.ts`. This copy lives under `src/` so the Vite plugin's
+ * local engine (which can't import across the editor `rootDir`) can read schema
+ * files. Keep all three in step.
+ */
+export declare function parseExportDefault(raw: string): Record<string, unknown>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/core/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/core/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAqDH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBvE"}