@otomata/editable 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexis Laporte (Otomata)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# @otomata/editable
+
+Micro-CMS embarqué pour les apps Otomata : les defaults du contenu vivent dans le code (registry TypeScript partagé front/back), les overrides édités vivent dans une table key/value. Édition inline dans la page (crayon → popovers), validation de forme côté serveur, retour aux defaults en un clic. Trois couches : `@otomata/editable` (core pur), `@otomata/editable/fastify` (plugin REST), `@otomata/editable/vue` (composants d'édition).
+
+## Registry partagé
+
+Le registry est le contrat : un module importable des deux côtés.
+
+```ts
+// shared/content-registry.ts
+import { defineContent } from "@otomata/editable";
+
+export const contentRegistry = {
+  landing: defineContent({
+    hero: { title: "Bienvenue", subtitle: "Sous-titre <accent>accentué</accent>" },
+    features: [{ label: "Rapide", detail: "…" }],
+  }),
+};
+```
+
+Les clés manquantes côté stockage sont comblées par les defaults (`mergeDeep`) ; les clés inconnues sont rejetées au `PUT` (`validateShape`). Modifier les defaults dans le code se propage donc sans migration.
+
+## Backend Fastify
+
+```ts
+import { contentPlugin, settingStorage } from "@otomata/editable/fastify";
+import { contentRegistry } from "../shared/content-registry.js";
+
+await app.register(contentPlugin, {
+  prefix: "/api/content",
+  registry: contentRegistry,
+  storage: settingStorage(prisma.setting, { prefix: "content:" }),
+  adminGuards: [requireAdmin],            // preHandlers Fastify ; GET reste public
+  getActor: (req) => req.user?.email,     // optionnel, passé à storage.set
+});
+```
+
+Routes : `GET /:slug` → `{ current, defaults }` ; `PUT /:slug` (guards) → 400 `Champ de contenu invalide : <path>` si la forme dévie ; `POST /:slug/reset` (guards) → defaults.
+
+`settingStorage` attend un delegate **structurel** style Prisma sur une table `{ key: string @id, value: string }` (`findUnique`/`upsert`/`deleteMany`) — aucun import Prisma dans le package. `memoryStorage()` pour les tests.
+
+### Consommateur Drizzle (waome, drizzle-orm 0.45)
+
+Pas d'adaptateur dédié : implémenter `ContentStorage` directement.
+
+```ts
+import { eq } from "drizzle-orm";
+import type { ContentStorage } from "@otomata/editable/fastify";
+
+const key = (slug: string) => `content:${slug}`;
+export const storage: ContentStorage = {
+  async get(slug) {
+    const [row] = await db.select().from(settings).where(eq(settings.key, key(slug)));
+    return row ? JSON.parse(row.value) : null;
+  },
+  async set(slug, data) {
+    const value = JSON.stringify(data);
+    await db.insert(settings).values({ key: key(slug), value })
+      .onConflictDoUpdate({ target: settings.key, set: { value } });
+  },
+  async remove(slug) {
+    await db.delete(settings).where(eq(settings.key, key(slug)));
+  },
+};
+```
+
+## Frontend Vue
+
+Installer le plugin (une fois) :
+
+```ts
+import { contentClient } from "@otomata/editable/vue";
+import { contentRegistry } from "../shared/content-registry.js";
+
+app.use(contentClient({
+  registry: contentRegistry,
+  baseUrl: "/api/content",                              // défaut
+  getAuthHeaders: async () => ({ authorization: `Bearer ${await getToken()}` }),
+}));
+```
+
+Dans une page :
+
+```vue
+<script setup lang="ts">
+import { CmsPage, CmsText, CmsList } from "@otomata/editable/vue";
+const isAdmin = /* … */;
+</script>
+
+<template>
+  <CmsPage slug="landing" :can-edit="isAdmin">
+    <h1><CmsText path="hero.title" tag="span" /></h1>
+    <p><CmsText path="hero.subtitle" accent /></p>
+    <ul>
+      <CmsList path="features" v-slot="{ path }">
+        <li><CmsText :path="`${path}.label`" /></li>
+      </CmsList>
+    </ul>
+  </CmsPage>
+</template>
+```
+
+- Rendu **immédiat** sur les defaults, hydratation `GET` au mounted (échec réseau → defaults, warn console).
+- `canEdit` affiche un crayon flottant ; en édition : clic sur un `CmsText` → popover textarea (preview live), barre flottante Enregistrer / Réinitialiser / Quitter.
+- `CmsText` : interpolation texte uniquement (jamais `v-html`) ; `\n` → `<br>` ; `accent` rend les segments `<accent>…</accent>` en `<span class="cms-accent">` (couleur via `--cms-accent-color`).
+- `CmsList` : "+ Ajouter" clone le **premier élément des defaults** ; tableau de defaults vide → pas de bouton.
+- Lecture seule hors `CmsPage` : `useContent(slug)` → `{ content, loading }`.
+
+## Distribution
+
+**Dans le monorepo** (npm workspaces) : dépendance `"@otomata/editable": "*"`, résolue en local. `.` et `./fastify` pointent vers `dist/` (committer ou builder avant usage : `npm run build --workspace @otomata/editable`) ; `./vue` reste en source brute, compilée par le Vite du consommateur.
+
+**Hors monorepo** (ex. waome) : pas de publication npm — vendoring par tarball.
+
+```bash
+cd oto-app && npm pack --workspace @otomata/editable   # → otomata-editable-0.1.0.tgz
+mv otomata-editable-*.tgz <consumer>/vendor/
+cd <consumer> && npm install ./vendor/otomata-editable-0.1.0.tgz
+```
+
+`prepack` rebuilde `dist/` ; le tarball contient `src/` + `dist/`.
+
+## Pièges connus
+
+- **Install par tarball + Vite** : ajouter `optimizeDeps: { exclude: ["@otomata/editable"] }` — l'entrée `./vue` est du TS/SFC brut, le pré-bundling esbuild de Vite ne doit pas y toucher.
+- **Styles** : composants autonomes (scoped, zéro Tailwind), personnalisables uniquement via les tokens `--cms-*` (`--cms-ink`, `--cms-surface`, `--cms-hair`, `--cms-accent`, `--cms-danger`, `--cms-accent-color`, `--cms-font-mono`, `--cms-banner-bg`, `--cms-banner-ink`). Le bandeau admin **réserve sa hauteur** (padding du `body`) et publie `--cms-banner-height` : les éléments `position: fixed` en haut de page doivent se décaler avec `top: var(--cms-banner-height, 0px)`.
+- **Concurrence** : pas de verrou ni de versioning — un seul admin à la fois, dernier `PUT` gagne (last-write-wins).
+- **Peer deps optionnelles** : `vue` et `fastify` sont des peers `optional` — installer celui qui correspond à la couche consommée.

package/dist/core/accent.d.ts

@@ -0,0 +1,9 @@
+export type AccentSegment = {
+    text: string;
+    accent: boolean;
+};
+/**
+ * Découpe un texte brut en lignes (\n) puis en segments accentués / non accentués
+ * sur les balises <accent>…</accent>. Une balise non fermée reste du texte brut.
+ */
+export declare function splitAccentLines(raw: string): AccentSegment[][];

package/dist/core/accent.js

@@ -0,0 +1,21 @@
+/**
+ * Découpe un texte brut en lignes (\n) puis en segments accentués / non accentués
+ * sur les balises <accent>…</accent>. Une balise non fermée reste du texte brut.
+ */
+export function splitAccentLines(raw) {
+    return raw.split("\n").map((line) => {
+        const segments = [];
+        const re = /<accent>(.*?)<\/accent>/g;
+        let last = 0;
+        let m;
+        while ((m = re.exec(line)) !== null) {
+            if (m.index > last)
+                segments.push({ text: line.slice(last, m.index), accent: false });
+            segments.push({ text: m[1] ?? "", accent: true });
+            last = m.index + m[0].length;
+        }
+        if (last < line.length)
+            segments.push({ text: line.slice(last), accent: false });
+        return segments;
+    });
+}

package/dist/core/define.d.ts

@@ -0,0 +1,2 @@
+import type { ContentDef } from "./types.js";
+export declare function defineContent<T>(defaults: T): ContentDef<T>;

package/dist/core/define.js

@@ -0,0 +1,3 @@
+export function defineContent(defaults) {
+    return { defaults };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export type { ContentDef, ContentRegistry, ContentDataOf } from "./types.js";
+export { defineContent } from "./define.js";
+export { mergeDeep } from "./merge.js";
+export { validateShape } from "./validate.js";
+export { getByPath, setByPath } from "./paths.js";
+export { splitAccentLines, type AccentSegment } from "./accent.js";

package/dist/core/index.js

@@ -0,0 +1,5 @@
+export { defineContent } from "./define.js";
+export { mergeDeep } from "./merge.js";
+export { validateShape } from "./validate.js";
+export { getByPath, setByPath } from "./paths.js";
+export { splitAccentLines } from "./accent.js";

package/dist/core/merge.d.ts

@@ -0,0 +1,2 @@
+/** Deep-merge : objets fusionnés récursivement ; tableaux et primitifs remplacés par l'override ; override undefined → base. */
+export declare function mergeDeep<T>(base: T, override: unknown): T;

package/dist/core/merge.js

@@ -0,0 +1,13 @@
+/** Deep-merge : objets fusionnés récursivement ; tableaux et primitifs remplacés par l'override ; override undefined → base. */
+export function mergeDeep(base, override) {
+    if (Array.isArray(base) || override === null || typeof override !== "object" || Array.isArray(override)) {
+        return override === undefined ? base : override;
+    }
+    if (base === null || typeof base !== "object")
+        return override;
+    const out = { ...base };
+    for (const [k, v] of Object.entries(override)) {
+        out[k] = k in out ? mergeDeep(out[k], v) : v;
+    }
+    return out;
+}

package/dist/core/paths.d.ts

@@ -0,0 +1,4 @@
+/** Lecture par path pointé ('hero.title', 'portes.0.label'). */
+export declare function getByPath(obj: unknown, path: string): unknown;
+/** Écriture immutable : clone uniquement le chemin touché, supporte les indices de tableaux. */
+export declare function setByPath<T>(obj: T, path: string, value: unknown): T;

package/dist/core/paths.js

@@ -0,0 +1,30 @@
+/** Lecture par path pointé ('hero.title', 'portes.0.label'). */
+export function getByPath(obj, path) {
+    if (!path)
+        return obj;
+    let cur = obj;
+    for (const p of path.split(".")) {
+        if (cur == null)
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+/** Écriture immutable : clone uniquement le chemin touché, supporte les indices de tableaux. */
+export function setByPath(obj, path, value) {
+    if (!path)
+        return value;
+    const parts = path.split(".");
+    const root = Array.isArray(obj) ? [...obj] : { ...obj };
+    let cur = root;
+    // `as string` : l'index est toujours < parts.length, mais les consommateurs
+    // avec noUncheckedIndexedAccess voient string | undefined.
+    for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        const next = cur[k];
+        cur[k] = Array.isArray(next) ? [...next] : { ...(next ?? {}) };
+        cur = cur[k];
+    }
+    cur[parts[parts.length - 1]] = value;
+    return root;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,5 @@
+export type ContentDef<T> = {
+    defaults: T;
+};
+export type ContentRegistry = Record<string, ContentDef<any>>;
+export type ContentDataOf<D> = D extends ContentDef<infer T> ? T : never;

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/validate.d.ts

@@ -0,0 +1 @@
+export declare function validateShape(data: unknown, shape: unknown, path?: string): string | null;

package/dist/core/validate.js

@@ -0,0 +1,45 @@
+/**
+ * Valide que `data` respecte la FORME de `shape` (les defaults d'un slug) :
+ * pas de clé inconnue (typo), types primitifs identiques, tableaux validés
+ * élément par élément contre le template (1er élément des defaults).
+ * Les clés manquantes sont acceptées : mergeDeep comble avec les defaults.
+ * Renvoie le path pointé du premier champ invalide, ou null si conforme.
+ */
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+export function validateShape(data, shape, path = "") {
+    // Pas de contrainte de forme (ex. champ libre) → accepté.
+    if (shape === null || shape === undefined)
+        return null;
+    if (Array.isArray(shape)) {
+        if (!Array.isArray(data))
+            return path || "(racine)";
+        const template = shape.length > 0 ? shape[0] : null;
+        if (template === null)
+            return null; // tableau de defaults vide : pas de template, on accepte
+        for (let i = 0; i < data.length; i++) {
+            const err = validateShape(data[i], template, `${path}[${i}]`);
+            if (err)
+                return err;
+        }
+        return null;
+    }
+    if (isPlainObject(shape)) {
+        if (!isPlainObject(data))
+            return path || "(racine)";
+        for (const key of Object.keys(data)) {
+            const childPath = path ? `${path}.${key}` : key;
+            if (!(key in shape))
+                return childPath;
+            const err = validateShape(data[key], shape[key], childPath);
+            if (err)
+                return err;
+        }
+        return null;
+    }
+    // Primitif : le type doit correspondre à celui du default.
+    if (typeof data !== typeof shape)
+        return path || "(racine)";
+    return null;
+}

package/dist/fastify/index.d.ts

@@ -0,0 +1,4 @@
+export { contentPlugin } from "./plugin.js";
+export type { ContentPluginOptions } from "./plugin.js";
+export { memoryStorage, settingStorage } from "./storage.js";
+export type { ContentStorage, SettingDelegate } from "./storage.js";

package/dist/fastify/index.js

@@ -0,0 +1,2 @@
+export { contentPlugin } from "./plugin.js";
+export { memoryStorage, settingStorage } from "./storage.js";

package/dist/fastify/plugin.d.ts

@@ -0,0 +1,17 @@
+import type { FastifyPluginAsync, FastifyRequest, preHandlerHookHandler } from "fastify";
+import type { ContentRegistry } from "../core/index.js";
+import type { ContentStorage } from "./storage.js";
+export type ContentPluginOptions = {
+    registry: ContentRegistry;
+    storage: ContentStorage;
+    adminGuards: preHandlerHookHandler[];
+    getActor?: (request: FastifyRequest) => string | undefined;
+};
+/**
+ * Plugin Fastify exposant le CRUD de contenu éditorial, scopé au prefix
+ * donné au register (ex. `/api/content`) :
+ *   GET  /:slug        → { current, defaults } (public)
+ *   PUT  /:slug        → validation de forme + persistance (adminGuards)
+ *   POST /:slug/reset  → retour aux defaults (adminGuards)
+ */
+export declare const contentPlugin: FastifyPluginAsync<ContentPluginOptions>;

package/dist/fastify/plugin.js

@@ -0,0 +1,45 @@
+import { mergeDeep, validateShape } from "../core/index.js";
+/**
+ * Plugin Fastify exposant le CRUD de contenu éditorial, scopé au prefix
+ * donné au register (ex. `/api/content`) :
+ *   GET  /:slug        → { current, defaults } (public)
+ *   PUT  /:slug        → validation de forme + persistance (adminGuards)
+ *   POST /:slug/reset  → retour aux defaults (adminGuards)
+ */
+export const contentPlugin = async (app, opts) => {
+    const { registry, storage, adminGuards, getActor } = opts;
+    app.get("/:slug", async (request, reply) => {
+        const { slug } = request.params;
+        const def = registry[slug];
+        if (!def) {
+            return reply.code(404).send({ error: `Contenu inconnu : ${slug}` });
+        }
+        const stored = await storage.get(slug);
+        return {
+            current: mergeDeep(def.defaults, stored ?? undefined),
+            defaults: def.defaults,
+        };
+    });
+    app.put("/:slug", { preHandler: adminGuards }, async (request, reply) => {
+        const { slug } = request.params;
+        const def = registry[slug];
+        if (!def) {
+            return reply.code(404).send({ error: `Contenu inconnu : ${slug}` });
+        }
+        const invalidPath = validateShape(request.body, def.defaults);
+        if (invalidPath !== null) {
+            return reply.code(400).send({ error: `Champ de contenu invalide : ${invalidPath}` });
+        }
+        await storage.set(slug, request.body, getActor?.(request));
+        return { current: request.body };
+    });
+    app.post("/:slug/reset", { preHandler: adminGuards }, async (request, reply) => {
+        const { slug } = request.params;
+        const def = registry[slug];
+        if (!def) {
+            return reply.code(404).send({ error: `Contenu inconnu : ${slug}` });
+        }
+        await storage.remove(slug);
+        return { current: def.defaults };
+    });
+};

package/dist/fastify/storage.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Abstractions de persistance du contenu éditorial.
+ * Le plugin Fastify ne connaît que l'interface ContentStorage ;
+ * deux implémentations : mémoire (tests/dev) et table Setting key/value (Prisma).
+ */
+export interface ContentStorage {
+    get(slug: string): Promise<unknown | null>;
+    set(slug: string, data: unknown, updatedBy?: string): Promise<void>;
+    remove(slug: string): Promise<void>;
+}
+/** Stockage en mémoire (tests, dev). */
+export declare function memoryStorage(): ContentStorage;
+/**
+ * Type STRUCTUREL compatible avec le delegate Prisma d'une table key/value :
+ * model Setting { key String @id ; value String }.
+ * Aucun import prisma : n'importe quel objet conforme convient.
+ */
+export type SettingDelegate = {
+    findUnique(args: {
+        where: {
+            key: string;
+        };
+    }): Promise<{
+        key: string;
+        value: string;
+    } | null>;
+    upsert(args: {
+        where: {
+            key: string;
+        };
+        update: {
+            value: string;
+        };
+        create: {
+            key: string;
+            value: string;
+        };
+    }): Promise<unknown>;
+    deleteMany(args: {
+        where: {
+            key: string;
+        };
+    }): Promise<unknown>;
+};
+/**
+ * Stockage sur une table Setting key/value.
+ * slug → clé = (prefix ?? '') + slug ; valeurs sérialisées en JSON.
+ * JSON invalide en base → console.warn + null (équivaut à « pas de donnée »).
+ */
+export declare function settingStorage(setting: SettingDelegate, opts?: {
+    prefix?: string;
+}): ContentStorage;

package/dist/fastify/storage.js

@@ -0,0 +1,51 @@
+/**
+ * Abstractions de persistance du contenu éditorial.
+ * Le plugin Fastify ne connaît que l'interface ContentStorage ;
+ * deux implémentations : mémoire (tests/dev) et table Setting key/value (Prisma).
+ */
+/** Stockage en mémoire (tests, dev). */
+export function memoryStorage() {
+    const store = new Map();
+    return {
+        async get(slug) {
+            return store.has(slug) ? store.get(slug) : null;
+        },
+        async set(slug, data) {
+            store.set(slug, data);
+        },
+        async remove(slug) {
+            store.delete(slug);
+        },
+    };
+}
+/**
+ * Stockage sur une table Setting key/value.
+ * slug → clé = (prefix ?? '') + slug ; valeurs sérialisées en JSON.
+ * JSON invalide en base → console.warn + null (équivaut à « pas de donnée »).
+ */
+export function settingStorage(setting, opts) {
+    const prefix = opts?.prefix ?? "";
+    const keyOf = (slug) => `${prefix}${slug}`;
+    return {
+        async get(slug) {
+            const row = await setting.findUnique({ where: { key: keyOf(slug) } });
+            if (!row)
+                return null;
+            try {
+                return JSON.parse(row.value);
+            }
+            catch {
+                console.warn(`@otomata/editable: JSON invalide en base pour la clé "${keyOf(slug)}", ignoré`);
+                return null;
+            }
+        },
+        async set(slug, data) {
+            const key = keyOf(slug);
+            const value = JSON.stringify(data);
+            await setting.upsert({ where: { key }, update: { value }, create: { key, value } });
+        },
+        async remove(slug) {
+            await setting.deleteMany({ where: { key: keyOf(slug) } });
+        },
+    };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@otomata/editable",
+  "version": "0.2.1",
+  "description": "Embeddable micro-CMS: content defaults in code, overrides in a key/value table, inline page editing. Core + Fastify plugin + Vue components.",
+  "license": "MIT",
+  "author": "Alexis Laporte (Otomata)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/otomata-tech/otomata-editable.git"
+  },
+  "homepage": "https://github.com/otomata-tech/otomata-editable#readme",
+  "keywords": [
+    "cms",
+    "micro-cms",
+    "inline-editing",
+    "fastify",
+    "vue",
+    "content"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify/index.d.ts",
+      "default": "./dist/fastify/index.js"
+    },
+    "./vue": "./src/vue/index.ts"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0",
+    "fastify": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "vue": "^3.5.0",
+    "fastify": "^5.0.0",
+    "typescript": "~5.9.0",
+    "vitest": "^4.0.0",
+    "vue-tsc": "^3.0.0",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "jsdom": "^28.0.0"
+  }
+}

package/src/core/accent.ts

@@ -0,0 +1,21 @@
+export type AccentSegment = { text: string; accent: boolean };
+
+/**
+ * Découpe un texte brut en lignes (\n) puis en segments accentués / non accentués
+ * sur les balises <accent>…</accent>. Une balise non fermée reste du texte brut.
+ */
+export function splitAccentLines(raw: string): AccentSegment[][] {
+  return raw.split("\n").map((line) => {
+    const segments: AccentSegment[] = [];
+    const re = /<accent>(.*?)<\/accent>/g;
+    let last = 0;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(line)) !== null) {
+      if (m.index > last) segments.push({ text: line.slice(last, m.index), accent: false });
+      segments.push({ text: m[1] ?? "", accent: true });
+      last = m.index + m[0].length;
+    }
+    if (last < line.length) segments.push({ text: line.slice(last), accent: false });
+    return segments;
+  });
+}

package/src/core/define.ts

@@ -0,0 +1,5 @@
+import type { ContentDef } from "./types.js";
+
+export function defineContent<T>(defaults: T): ContentDef<T> {
+  return { defaults };
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+export type { ContentDef, ContentRegistry, ContentDataOf } from "./types.js";
+export { defineContent } from "./define.js";
+export { mergeDeep } from "./merge.js";
+export { validateShape } from "./validate.js";
+export { getByPath, setByPath } from "./paths.js";
+export { splitAccentLines, type AccentSegment } from "./accent.js";

package/src/core/merge.ts

@@ -0,0 +1,12 @@
+/** Deep-merge : objets fusionnés récursivement ; tableaux et primitifs remplacés par l'override ; override undefined → base. */
+export function mergeDeep<T>(base: T, override: unknown): T {
+  if (Array.isArray(base) || override === null || typeof override !== "object" || Array.isArray(override)) {
+    return override === undefined ? base : (override as T);
+  }
+  if (base === null || typeof base !== "object") return override as T;
+  const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };
+  for (const [k, v] of Object.entries(override as Record<string, unknown>)) {
+    out[k] = k in out ? mergeDeep(out[k], v) : v;
+  }
+  return out as T;
+}

package/src/core/paths.ts

@@ -0,0 +1,28 @@
+/** Lecture par path pointé ('hero.title', 'portes.0.label'). */
+export function getByPath(obj: unknown, path: string): unknown {
+  if (!path) return obj;
+  let cur: any = obj;
+  for (const p of path.split(".")) {
+    if (cur == null) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+/** Écriture immutable : clone uniquement le chemin touché, supporte les indices de tableaux. */
+export function setByPath<T>(obj: T, path: string, value: unknown): T {
+  if (!path) return value as T;
+  const parts = path.split(".");
+  const root: any = Array.isArray(obj) ? [...(obj as any)] : { ...(obj as any) };
+  let cur: any = root;
+  // `as string` : l'index est toujours < parts.length, mais les consommateurs
+  // avec noUncheckedIndexedAccess voient string | undefined.
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i] as string;
+    const next = cur[k];
+    cur[k] = Array.isArray(next) ? [...next] : { ...(next ?? {}) };
+    cur = cur[k];
+  }
+  cur[parts[parts.length - 1] as string] = value;
+  return root;
+}

package/src/core/types.ts

@@ -0,0 +1,5 @@
+export type ContentDef<T> = { defaults: T };
+
+export type ContentRegistry = Record<string, ContentDef<any>>;
+
+export type ContentDataOf<D> = D extends ContentDef<infer T> ? T : never;