@qwanyx/ai-editor 1.3.13 → 1.4.0

package/dist/types/page.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Types pour le système de Pages et Sections
+ * Extension de qwanyx-ai-editor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DROP_CAP = exports.VIDEO_PRESETS = exports.PRINT_PRESETS = void 0;
+exports.generateId = generateId;
+exports.createSection = createSection;
+exports.createEmptyPage = createEmptyPage;
+// Presets communs
+exports.PRINT_PRESETS = {
+    A4: { width: 210, height: 297, unit: 'mm', name: 'A4' },
+    A3: { width: 297, height: 420, unit: 'mm', name: 'A3' },
+    Letter: { width: 8.5, height: 11, unit: 'in', name: 'Letter' },
+    Legal: { width: 8.5, height: 14, unit: 'in', name: 'Legal' },
+};
+exports.VIDEO_PRESETS = {
+    'Full HD': { width: 1920, height: 1080, name: 'Full HD (16:9)' },
+    '4K': { width: 3840, height: 2160, name: '4K UHD (16:9)' },
+    'HD': { width: 1280, height: 720, name: 'HD (16:9)' },
+    'Square': { width: 1080, height: 1080, name: 'Carré (1:1)' },
+    'Portrait': { width: 1080, height: 1920, name: 'Portrait (9:16)' },
+    '4:3': { width: 1024, height: 768, name: 'Standard (4:3)' },
+};
+exports.DEFAULT_DROP_CAP = {
+    enabled: true,
+    type: 'letter',
+    fontSize: 3,
+    lineHeight: 3,
+};
+// ============================================
+// Helpers
+// ============================================
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function createSection(layoutType, content, animation) {
+    return {
+        id: generateId(),
+        layoutType,
+        content,
+        animation,
+    };
+}
+function createEmptyPage(format = 'web') {
+    return {
+        id: generateId(),
+        format,
+        sections: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Utilitaires pour la détection et conversion de formats
+ *
+ * Gère la rétrocompatibilité entre:
+ * - Ancien format: JSON Lexical brut (string)
+ * - Nouveau format: PageDocument avec sections
+ */
+import { PageDocument } from '../types/page';
+export type ContentFormat = 'lexical' | 'page-document' | 'empty' | 'unknown';
+export interface FormatDetectionResult {
+    format: ContentFormat;
+    data: PageDocument | string | null;
+}
+/**
+ * Détecte le format du contenu
+ *
+ * @param content - Le contenu à analyser (string JSON ou objet)
+ * @returns Le type de format détecté et les données parsées
+ */
+export declare function detectFormat(content: string | PageDocument | null | undefined): FormatDetectionResult;
+/**
+ * Vérifie si un objet est un PageDocument valide
+ */
+export declare function isPageDocument(obj: unknown): obj is PageDocument;
+/**
+ * Vérifie si un objet est un état Lexical valide
+ */
+export declare function isLexicalState(obj: unknown): boolean;
+/**
+ * Convertit du contenu Lexical brut en PageDocument
+ * Crée une page avec une seule section "text-only" contenant l'éditeur
+ *
+ * @param lexicalContent - Le JSON Lexical (string ou objet)
+ * @param format - Le format de page souhaité (défaut: 'web')
+ * @returns Un PageDocument avec le contenu Lexical dans une section
+ */
+export declare function lexicalToPageDocument(lexicalContent: string | object, format?: 'web' | 'print' | 'video'): PageDocument;
+/**
+ * Extrait le contenu Lexical d'un PageDocument
+ * Si le document a une seule section "text-only", retourne le Lexical brut
+ * Sinon, retourne null (le document utilise le nouveau format)
+ *
+ * @param document - Le PageDocument à analyser
+ * @returns Le JSON Lexical si applicable, sinon null
+ */
+export declare function pageDocumentToLexical(document: PageDocument): string | null;
+/**
+ * Convertit automatiquement le contenu vers PageDocument si nécessaire
+ *
+ * @param content - Le contenu (peut être Lexical ou PageDocument)
+ * @returns Un PageDocument valide
+ */
+export declare function ensurePageDocument(content: string | PageDocument | null | undefined): PageDocument;
+/**
+ * Vérifie si un PageDocument est "simple" (une seule section text-only)
+ * Utile pour décider comment sauvegarder
+ */
+export declare function isSimpleDocument(document: PageDocument): boolean;
+export interface SaveOptions {
+    /** Si true, sauvegarde en Lexical brut si possible (rétrocompatibilité) */
+    preferLegacyFormat?: boolean;
+}
+/**
+ * Prépare le contenu pour la sauvegarde
+ *
+ * @param document - Le PageDocument à sauvegarder
+ * @param options - Options de sauvegarde
+ * @returns String JSON à sauvegarder
+ */
+export declare function prepareForSave(document: PageDocument, options?: SaveOptions): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,YAAY,EAIb,MAAM,eAAe,CAAA;AAOtB,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,eAAe,GAAG,OAAO,GAAG,SAAS,CAAA;AAE7E,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,aAAa,CAAA;IACrB,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,CAAA;CACnC;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS,GAAG,qBAAqB,CA4CrG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,YAAY,CAahE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAYpD;AAMD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,GAAG,MAAM,EAC/B,MAAM,GAAE,KAAK,GAAG,OAAO,GAAG,OAAe,GACxC,YAAY,CAoBd;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,CAQ3E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,CAelG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAKhE;AAMD,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,GAAE,WAAgB,GAAG,MAAM,CAaxF"}

package/dist/utils/format.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Utilitaires pour la détection et conversion de formats
+ *
+ * Gère la rétrocompatibilité entre:
+ * - Ancien format: JSON Lexical brut (string)
+ * - Nouveau format: PageDocument avec sections
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFormat = detectFormat;
+exports.isPageDocument = isPageDocument;
+exports.isLexicalState = isLexicalState;
+exports.lexicalToPageDocument = lexicalToPageDocument;
+exports.pageDocumentToLexical = pageDocumentToLexical;
+exports.ensurePageDocument = ensurePageDocument;
+exports.isSimpleDocument = isSimpleDocument;
+exports.prepareForSave = prepareForSave;
+const page_1 = require("../types/page");
+// ============================================
+// Détection du format
+// ============================================
+/**
+ * Détecte le format du contenu
+ *
+ * @param content - Le contenu à analyser (string JSON ou objet)
+ * @returns Le type de format détecté et les données parsées
+ */
+function detectFormat(content) {
+    // Cas vide
+    if (!content) {
+        return { format: 'empty', data: null };
+    }
+    // Si c'est déjà un objet
+    if (typeof content === 'object') {
+        if (isPageDocument(content)) {
+            return { format: 'page-document', data: content };
+        }
+        // Objet mais pas un PageDocument - probablement du Lexical parsé
+        return { format: 'lexical', data: JSON.stringify(content) };
+    }
+    // C'est une string - essayer de parser
+    if (typeof content === 'string') {
+        // String vide
+        if (!content.trim()) {
+            return { format: 'empty', data: null };
+        }
+        try {
+            const parsed = JSON.parse(content);
+            // Vérifier si c'est un PageDocument
+            if (isPageDocument(parsed)) {
+                return { format: 'page-document', data: parsed };
+            }
+            // Vérifier si c'est du Lexical (a un "root" avec "children")
+            if (isLexicalState(parsed)) {
+                return { format: 'lexical', data: content };
+            }
+            // JSON valide mais format inconnu
+            return { format: 'unknown', data: content };
+        }
+        catch {
+            // Pas du JSON - texte brut, on le traite comme vide ou texte simple
+            return { format: 'unknown', data: content };
+        }
+    }
+    return { format: 'unknown', data: null };
+}
+/**
+ * Vérifie si un objet est un PageDocument valide
+ */
+function isPageDocument(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const doc = obj;
+    // Doit avoir un id et un format
+    if (typeof doc.id !== 'string')
+        return false;
+    if (!['web', 'print', 'video'].includes(doc.format))
+        return false;
+    // Doit avoir un array sections
+    if (!Array.isArray(doc.sections))
+        return false;
+    return true;
+}
+/**
+ * Vérifie si un objet est un état Lexical valide
+ */
+function isLexicalState(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const state = obj;
+    // Lexical state a toujours un "root" avec des "children"
+    if (!state.root || typeof state.root !== 'object')
+        return false;
+    const root = state.root;
+    if (!Array.isArray(root.children))
+        return false;
+    return true;
+}
+// ============================================
+// Conversion de format
+// ============================================
+/**
+ * Convertit du contenu Lexical brut en PageDocument
+ * Crée une page avec une seule section "text-only" contenant l'éditeur
+ *
+ * @param lexicalContent - Le JSON Lexical (string ou objet)
+ * @param format - Le format de page souhaité (défaut: 'web')
+ * @returns Un PageDocument avec le contenu Lexical dans une section
+ */
+function lexicalToPageDocument(lexicalContent, format = 'web') {
+    const lexicalString = typeof lexicalContent === 'string'
+        ? lexicalContent
+        : JSON.stringify(lexicalContent);
+    const section = {
+        id: (0, page_1.generateId)(),
+        layoutType: 'text-only',
+        content: {
+            lexicalState: lexicalString,
+        },
+    };
+    return {
+        id: (0, page_1.generateId)(),
+        format,
+        sections: [section],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+}
+/**
+ * Extrait le contenu Lexical d'un PageDocument
+ * Si le document a une seule section "text-only", retourne le Lexical brut
+ * Sinon, retourne null (le document utilise le nouveau format)
+ *
+ * @param document - Le PageDocument à analyser
+ * @returns Le JSON Lexical si applicable, sinon null
+ */
+function pageDocumentToLexical(document) {
+    // Si le document a exactement une section de type "text-only"
+    if (document.sections.length === 1 && document.sections[0].layoutType === 'text-only') {
+        const content = document.sections[0].content;
+        return content.lexicalState || null;
+    }
+    return null;
+}
+/**
+ * Convertit automatiquement le contenu vers PageDocument si nécessaire
+ *
+ * @param content - Le contenu (peut être Lexical ou PageDocument)
+ * @returns Un PageDocument valide
+ */
+function ensurePageDocument(content) {
+    const detection = detectFormat(content);
+    switch (detection.format) {
+        case 'page-document':
+            return detection.data;
+        case 'lexical':
+            return lexicalToPageDocument(detection.data);
+        case 'empty':
+        case 'unknown':
+        default:
+            return (0, page_1.createEmptyPage)('web');
+    }
+}
+/**
+ * Vérifie si un PageDocument est "simple" (une seule section text-only)
+ * Utile pour décider comment sauvegarder
+ */
+function isSimpleDocument(document) {
+    return (document.sections.length === 1 &&
+        document.sections[0].layoutType === 'text-only');
+}
+/**
+ * Prépare le contenu pour la sauvegarde
+ *
+ * @param document - Le PageDocument à sauvegarder
+ * @param options - Options de sauvegarde
+ * @returns String JSON à sauvegarder
+ */
+function prepareForSave(document, options = {}) {
+    const { preferLegacyFormat = false } = options;
+    // Si on préfère le format legacy et que c'est possible
+    if (preferLegacyFormat && isSimpleDocument(document)) {
+        const lexical = pageDocumentToLexical(document);
+        if (lexical) {
+            return lexical;
+        }
+    }
+    // Sinon, sauvegarder comme PageDocument
+    return JSON.stringify(document);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export all utilities
+ */
+export * from './format';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,UAAU,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Re-export all utilities
+ */
+__exportStar(require("./format"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwanyx/ai-editor",
-  "version": "1.3.13",
+  "version": "1.4.0",
   "description": "AI-powered WYSIWYG rich text editor",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",