@bayonai/rich-text-editor 0.1.2 → 1.0.0

package/dist/core/exportImport.d.ts

@@ -0,0 +1,59 @@
+import { type RichTextEditorEntitlements, type RichTextFeatureGate } from "./features";
+import type { RichTextBlock } from "./types";
+export type RichTextExportPayload = {
+    data: string;
+    extension: string;
+    filename?: string;
+    format: string;
+    mimeType: string;
+};
+export type RichTextExportAdapter = {
+    exportBlocks: (blocks: RichTextBlock[]) => RichTextExportPayload;
+    extension: string;
+    id: string;
+    label: string;
+    mimeType: string;
+};
+export type RichTextImportAdapter = {
+    extension: string;
+    id: string;
+    importData: (data: string) => unknown;
+    label: string;
+    mimeType: string;
+};
+export type RichTextExportImportResult<Value> = {
+    ok: true;
+    value: Value;
+} | {
+    gate: RichTextFeatureGate;
+    ok: false;
+};
+export declare const richTextJsonExportAdapter: {
+    extension: string;
+    exportBlocks: (blocks: RichTextBlock[]) => {
+        data: string;
+        extension: string;
+        format: string;
+        mimeType: string;
+    };
+    id: string;
+    label: string;
+    mimeType: string;
+};
+export declare const richTextJsonImportAdapter: {
+    extension: string;
+    id: string;
+    importData: (data: string) => unknown;
+    label: string;
+    mimeType: string;
+};
+export declare function exportRichTextBlocks({ adapter, blocks, features, }: {
+    adapter: RichTextExportAdapter;
+    blocks: RichTextBlock[];
+    features?: RichTextEditorEntitlements;
+}): Promise<RichTextExportImportResult<RichTextExportPayload>>;
+export declare function importRichTextBlocks({ adapter, data, features, }: {
+    adapter: RichTextImportAdapter;
+    data: string;
+    features?: RichTextEditorEntitlements;
+}): Promise<RichTextExportImportResult<RichTextBlock[]>>;

package/dist/core/exportImport.js

@@ -0,0 +1,51 @@
+import { getRichTextFeatureAccess, } from "./features.js";
+import { sanitizeRichTextBlocks } from "./richText.js";
+export const richTextJsonExportAdapter = {
+    extension: "json",
+    exportBlocks: (blocks) => ({
+        data: JSON.stringify(sanitizeRichTextBlocks(blocks), null, 2),
+        extension: "json",
+        format: "bayon-rich-text-json",
+        mimeType: "application/json",
+    }),
+    id: "bayon-rich-text-json",
+    label: "Bayon rich text JSON",
+    mimeType: "application/json",
+};
+export const richTextJsonImportAdapter = {
+    extension: "json",
+    id: "bayon-rich-text-json",
+    importData: (data) => JSON.parse(data),
+    label: "Bayon rich text JSON",
+    mimeType: "application/json",
+};
+export async function exportRichTextBlocks({ adapter, blocks, features, }) {
+    const gate = getExportImportGate(features);
+    if (gate) {
+        return { gate, ok: false };
+    }
+    return {
+        ok: true,
+        value: adapter.exportBlocks(sanitizeRichTextBlocks(blocks)),
+    };
+}
+export async function importRichTextBlocks({ adapter, data, features, }) {
+    const gate = getExportImportGate(features);
+    if (gate) {
+        return { gate, ok: false };
+    }
+    return {
+        ok: true,
+        value: sanitizeRichTextBlocks(adapter.importData(data)),
+    };
+}
+function getExportImportGate(features) {
+    const access = getRichTextFeatureAccess(features, "export-import");
+    return access.enabled
+        ? null
+        : {
+            featureId: access.featureId,
+            label: access.label,
+            reason: access.reason,
+        };
+}

package/dist/core/features.d.ts

@@ -0,0 +1,59 @@
+export type RichTextEditorFeatureId = "image-upload" | "transcription" | "export-import" | "comments" | "review-marks" | "schema-migrations" | "templates" | "collaboration";
+export type RichTextEditorFeatureTier = "free" | "pro";
+export type RichTextEditorEntitlements = Partial<Record<RichTextEditorFeatureId, boolean>>;
+export type RichTextLockedFeatureMode = "disabled" | "hide";
+export type RichTextFeatureGateReason = "disabled" | "premium" | "unavailable";
+export type RichTextFeatureGate = {
+    featureId: RichTextEditorFeatureId;
+    label: string;
+    reason: RichTextFeatureGateReason;
+};
+export type RichTextFeatureAccess = {
+    enabled: true;
+    featureId: RichTextEditorFeatureId;
+    label: string;
+    reason?: undefined;
+    tier: RichTextEditorFeatureTier;
+} | {
+    enabled: false;
+    featureId: RichTextEditorFeatureId;
+    label: string;
+    reason: RichTextFeatureGateReason;
+    tier: RichTextEditorFeatureTier;
+};
+export declare const richTextEditorFeatureCatalog: {
+    readonly "image-upload": {
+        readonly label: "Image upload";
+        readonly tier: "free";
+    };
+    readonly transcription: {
+        readonly label: "Transcription";
+        readonly tier: "free";
+    };
+    readonly "export-import": {
+        readonly label: "Export and import";
+        readonly tier: "pro";
+    };
+    readonly comments: {
+        readonly label: "Comments";
+        readonly tier: "pro";
+    };
+    readonly "review-marks": {
+        readonly label: "Review marks";
+        readonly tier: "pro";
+    };
+    readonly "schema-migrations": {
+        readonly label: "Schema migrations";
+        readonly tier: "pro";
+    };
+    readonly templates: {
+        readonly label: "Templates";
+        readonly tier: "pro";
+    };
+    readonly collaboration: {
+        readonly label: "Collaboration";
+        readonly tier: "pro";
+    };
+};
+export declare function getRichTextFeatureAccess(features: RichTextEditorEntitlements | undefined, featureId: RichTextEditorFeatureId): RichTextFeatureAccess;
+export declare function isRichTextFeatureEnabled(features: RichTextEditorEntitlements | undefined, featureId: RichTextEditorFeatureId): boolean;

package/dist/core/features.js

@@ -0,0 +1,57 @@
+export const richTextEditorFeatureCatalog = {
+    "image-upload": {
+        label: "Image upload",
+        tier: "free",
+    },
+    transcription: {
+        label: "Transcription",
+        tier: "free",
+    },
+    "export-import": {
+        label: "Export and import",
+        tier: "pro",
+    },
+    comments: {
+        label: "Comments",
+        tier: "pro",
+    },
+    "review-marks": {
+        label: "Review marks",
+        tier: "pro",
+    },
+    "schema-migrations": {
+        label: "Schema migrations",
+        tier: "pro",
+    },
+    templates: {
+        label: "Templates",
+        tier: "pro",
+    },
+    collaboration: {
+        label: "Collaboration",
+        tier: "pro",
+    },
+};
+export function getRichTextFeatureAccess(features, featureId) {
+    const feature = richTextEditorFeatureCatalog[featureId];
+    const enabled = features?.[featureId] ?? true;
+    if (enabled) {
+        return {
+            enabled: true,
+            featureId,
+            label: feature.label,
+            reason: undefined,
+            tier: feature.tier,
+        };
+    }
+    return {
+        enabled: false,
+        featureId,
+        label: feature.label,
+        reason: feature.tier === "pro" ? "premium" : "disabled",
+        tier: feature.tier,
+    };
+}
+export function isRichTextFeatureEnabled(features, featureId) {
+    return getRichTextFeatureAccess(features, featureId).enabled;
+}

package/dist/core/imageBlockDiagnostics.d.ts

@@ -0,0 +1,4 @@
+import type { RichTextBlock } from "./types";
+export type MissingImageBlockMetadata = "alt" | "url";
+export declare function getMissingImageBlockMetadata(block: RichTextBlock): MissingImageBlockMetadata[];
+export declare function warnIfImageBlockMissingDisplayUrl(block: RichTextBlock): void;

package/dist/core/imageBlockDiagnostics.js

@@ -0,0 +1,19 @@
+export function getMissingImageBlockMetadata(block) {
+    if (block.type !== "image") {
+        return [];
+    }
+    return [
+        block.url?.trim() ? null : "url",
+        block.alt?.trim() ? null : "alt",
+    ].filter((field) => field !== null);
+}
+export function warnIfImageBlockMissingDisplayUrl(block) {
+    const missing = getMissingImageBlockMetadata(block);
+    if (block.type !== "image" ||
+        typeof block.uploadProgress === "number" ||
+        !missing.includes("url") ||
+        missing.includes("alt")) {
+        return;
+    }
+    console.warn("Rich text image block is missing a display URL.", { block });
+}

package/dist/core/proFeatures.d.ts

@@ -0,0 +1,60 @@
+import { type RichTextEditorEntitlements, type RichTextFeatureGate } from "./features";
+import type { RichTextBlock } from "./types";
+type RichTextProResult<Value> = {
+    ok: true;
+    value: Value;
+} | {
+    gate: RichTextFeatureGate;
+    ok: false;
+};
+export type RichTextSchemaMigration = {
+    id: string;
+    migrate: (blocks: RichTextBlock[]) => unknown;
+};
+export type RichTextSchemaMigrationResult = {
+    appliedMigrationIds: string[];
+    blocks: RichTextBlock[];
+};
+export type RichTextTemplate<Variables = Record<string, unknown>> = {
+    createBlocks: (variables: Variables) => unknown;
+    id: string;
+    label: string;
+};
+export type RichTextCollaborationAdapter<Session = unknown> = {
+    connect: (input: {
+        blocks: RichTextBlock[];
+    }) => Promise<Session> | Session;
+    id: string;
+    label: string;
+};
+export type RichTextAnnotation = {
+    blockId: string;
+    id: string;
+    kind: "comment";
+    text?: string;
+} | {
+    blockId: string;
+    id: string;
+    kind: "review-mark";
+    text?: string;
+};
+export declare function runRichTextSchemaMigrations({ blocks, features, migrations, }: {
+    blocks: RichTextBlock[];
+    features?: RichTextEditorEntitlements;
+    migrations: RichTextSchemaMigration[];
+}): Promise<RichTextProResult<RichTextSchemaMigrationResult>>;
+export declare function instantiateRichTextTemplate<Variables>({ features, template, variables, }: {
+    features?: RichTextEditorEntitlements;
+    template: RichTextTemplate<Variables>;
+    variables: Variables;
+}): Promise<RichTextProResult<RichTextBlock[]>>;
+export declare function connectRichTextCollaboration<Session>({ adapter, blocks, features, }: {
+    adapter: RichTextCollaborationAdapter<Session>;
+    blocks: RichTextBlock[];
+    features?: RichTextEditorEntitlements;
+}): Promise<RichTextProResult<Session>>;
+export declare function createRichTextAnnotations({ annotations, features, }: {
+    annotations: RichTextAnnotation[];
+    features?: RichTextEditorEntitlements;
+}): RichTextProResult<RichTextAnnotation[]>;
+export {};

package/dist/core/proFeatures.js

@@ -0,0 +1,64 @@
+import { getRichTextFeatureAccess, } from "./features.js";
+import { sanitizeRichTextBlocks } from "./richText.js";
+export async function runRichTextSchemaMigrations({ blocks, features, migrations, }) {
+    const gate = getProFeatureGate(features, "schema-migrations");
+    if (gate) {
+        return { gate, ok: false };
+    }
+    let nextBlocks = sanitizeRichTextBlocks(blocks);
+    const appliedMigrationIds = [];
+    for (const migration of migrations) {
+        nextBlocks = sanitizeRichTextBlocks(migration.migrate(nextBlocks));
+        appliedMigrationIds.push(migration.id);
+    }
+    return {
+        ok: true,
+        value: { appliedMigrationIds, blocks: nextBlocks },
+    };
+}
+export async function instantiateRichTextTemplate({ features, template, variables, }) {
+    const gate = getProFeatureGate(features, "templates");
+    if (gate) {
+        return { gate, ok: false };
+    }
+    return {
+        ok: true,
+        value: sanitizeRichTextBlocks(template.createBlocks(variables)),
+    };
+}
+export async function connectRichTextCollaboration({ adapter, blocks, features, }) {
+    const gate = getProFeatureGate(features, "collaboration");
+    if (gate) {
+        return { gate, ok: false };
+    }
+    return {
+        ok: true,
+        value: await adapter.connect({ blocks: sanitizeRichTextBlocks(blocks) }),
+    };
+}
+export function createRichTextAnnotations({ annotations, features, }) {
+    const reviewGate = annotations.some((annotation) => annotation.kind === "review-mark")
+        ? getProFeatureGate(features, "review-marks")
+        : null;
+    const commentGate = annotations.some((annotation) => annotation.kind === "comment")
+        ? getProFeatureGate(features, "comments")
+        : null;
+    const gate = reviewGate ?? commentGate;
+    if (gate) {
+        return { gate, ok: false };
+    }
+    return {
+        ok: true,
+        value: annotations.filter((annotation) => annotation.id.trim() && annotation.blockId.trim()),
+    };
+}
+function getProFeatureGate(features, featureId) {
+    const access = getRichTextFeatureAccess(features, featureId);
+    return access.enabled
+        ? null
+        : {
+            featureId: access.featureId,
+            label: access.label,
+            reason: access.reason,
+        };
+}

package/dist/{richText.d.ts → core/richText.d.ts}

@@ -10,6 +10,8 @@ export declare function createRichTextBlockId(): string;
 export declare function sanitizeRichTextBlocks(value: unknown): RichTextBlock[];
 export declare function isRichTextBlocksEmpty(blocks: RichTextBlock[]): boolean;
 export declare function richTextBlocksToPlainText(blocks: RichTextBlock[]): string;
+export declare function encodeRichTextBlocksForClipboard(blocks: RichTextBlock[]): string;
+export declare function decodeRichTextBlocksFromClipboardText(value: string): RichTextBlock[] | null;
 export declare function editorHtmlToMarkdown(html: string): string;
 export declare function markdownToEditorHtml(markdown: string): string;
 export declare function sanitizeRichTextHtml(html: string): string;