writetrack 0.6.1 → 0.8.0

package/dist/lexical/index.d.ts

@@ -0,0 +1,75 @@
+import { WriteTrack } from 'writetrack';
+
+export interface WriteTrackLexicalOptions {
+  /** WriteTrack license key */
+  license?: string;
+  /** User identifier for metadata */
+  userId?: string;
+  /** Content identifier for metadata */
+  contentId?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+  /** Auto-start tracking when editor root is available (default: true) */
+  autoStart?: boolean;
+  /** URL to the WASM binary for analysis. If omitted, uses default loader path. */
+  wasmUrl?: string;
+  /** Enable IndexedDB session persistence and auto-resume. Requires contentId. */
+  persist?: boolean;
+}
+
+export interface WriteTrackLexicalHandle {
+  /** The underlying WriteTrack instance (null until root element is available) */
+  tracker: WriteTrack | null;
+  /** Whether tracking is currently active */
+  isTracking: boolean;
+  /** Stop tracking and clean up resources */
+  destroy(): void;
+}
+
+/**
+ * Attach WriteTrack to a Lexical editor.
+ *
+ * Uses `editor.registerRootListener()` to discover the contenteditable element.
+ * The tracker is created when the root becomes available and destroyed when
+ * the root is removed or `destroy()` is called.
+ *
+ * @example
+ * ```ts
+ * import { createEditor } from 'lexical';
+ * import { createWriteTrackLexical } from 'writetrack/lexical';
+ *
+ * import { createEditor, $getSelection } from 'lexical';
+ * import { createWriteTrackLexical } from 'writetrack/lexical';
+ *
+ * const editor = createEditor({ ... });
+ * const handle = createWriteTrackLexical(editor, $getSelection, {
+ *   license: 'your-license-key',
+ * });
+ *
+ * // Access tracker
+ * const data = handle.tracker?.getData();
+ *
+ * // Clean up
+ * handle.destroy();
+ * ```
+ *
+ * @param editor - A Lexical `LexicalEditor` instance
+ * @param $getSelection - Lexical's `$getSelection` function for cursor position tracking
+ * @param options - WriteTrack configuration options
+ * @returns A handle with the tracker instance and a destroy method
+ */
+export declare function createWriteTrackLexical(
+  editor: {
+    registerRootListener(
+      listener: (
+        rootElement: HTMLElement | null,
+        prevRootElement: HTMLElement | null
+      ) => void
+    ): () => void;
+    getEditorState(): {
+      read<T>(callback: () => T): T;
+    };
+  },
+  $getSelection: () => { anchor?: { offset: number } } | null,
+  options: WriteTrackLexicalOptions
+): WriteTrackLexicalHandle;

package/dist/lexical/index.js

@@ -0,0 +1 @@
+import{WriteTrack as k}from"writetrack";function u(n,c,r){let s=r.autoStart!==!1,e={tracker:null,isTracking:!1,destroy(){e.tracker&&(e.tracker.stop(),e.tracker=null,e.isTracking=!1),o()}};function l(t){e.tracker=new k({target:t,license:r.license,userId:r.userId,contentId:r.contentId,metadata:r.metadata,wasmUrl:r.wasmUrl,persist:r.persist,cursorPositionProvider:()=>{try{return n.getEditorState().read(()=>{let a=c();return a&&typeof a.anchor?.offset=="number"?a.anchor.offset:0})}catch{return 0}}}),s&&(r.persist?e.tracker.ready.then(()=>{e.tracker&&(e.tracker.start(),e.isTracking=!0)}):(e.tracker.start(),e.isTracking=!0))}function i(){e.tracker&&(e.tracker.stop(),e.tracker=null,e.isTracking=!1)}let o=n.registerRootListener(t=>{t?(i(),l(t)):i()});return e}export{u as createWriteTrackLexical};

package/dist/slate/index.d.ts

@@ -0,0 +1,64 @@
+import { WriteTrack } from 'writetrack';
+
+export interface WriteTrackSlateOptions {
+  /** WriteTrack license key */
+  license?: string;
+  /** User identifier for metadata */
+  userId?: string;
+  /** Content identifier for metadata */
+  contentId?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+  /** Auto-start tracking when created (default: true) */
+  autoStart?: boolean;
+  /** URL to the WASM binary for analysis. If omitted, uses default loader path. */
+  wasmUrl?: string;
+  /** Enable IndexedDB session persistence and auto-resume. Requires contentId. */
+  persist?: boolean;
+}
+
+export interface WriteTrackSlateHandle {
+  /** The underlying WriteTrack instance */
+  tracker: WriteTrack | null;
+  /** Whether tracking is currently active */
+  isTracking: boolean;
+  /** Stop tracking and clean up resources */
+  destroy(): void;
+}
+
+/**
+ * Attach WriteTrack to a Slate editor.
+ *
+ * Slate is React-based and does not provide a built-in destroy lifecycle,
+ * so `destroy()` must be called manually (e.g. in a useEffect cleanup).
+ *
+ * @example
+ * ```ts
+ * import { createEditor } from 'slate';
+ * import { createWriteTrackSlate } from 'writetrack/slate';
+ *
+ * const editor = createEditor();
+ * const editableRef = document.querySelector('[data-slate-editor]');
+ * const handle = createWriteTrackSlate(editor, editableRef, {
+ *   license: 'your-license-key',
+ * });
+ *
+ * // Access tracker
+ * const data = handle.tracker?.getData();
+ *
+ * // Clean up
+ * handle.destroy();
+ * ```
+ *
+ * @param editor - A Slate `Editor` instance
+ * @param element - The contenteditable DOM element (e.g. from a ref on `<Editable>`)
+ * @param options - WriteTrack configuration options
+ * @returns A handle with the tracker instance and a destroy method
+ */
+export declare function createWriteTrackSlate(
+  editor: {
+    selection: { anchor: { offset: number }; focus: { offset: number } } | null;
+  },
+  element: HTMLElement,
+  options: WriteTrackSlateOptions
+): WriteTrackSlateHandle;

package/dist/slate/index.js

@@ -0,0 +1 @@
+import{WriteTrack as c}from"writetrack";function i(t,a,e){let n=e.autoStart!==!1,r={tracker:null,isTracking:!1,destroy(){r.tracker&&(r.tracker.stop(),r.tracker=null,r.isTracking=!1)}};return r.tracker=new c({target:a,license:e.license,userId:e.userId,contentId:e.contentId,metadata:e.metadata,wasmUrl:e.wasmUrl,persist:e.persist,cursorPositionProvider:()=>t.selection?.anchor.offset??0}),n&&(e.persist?r.tracker.ready.then(()=>{r.tracker&&(r.tracker.start(),r.isTracking=!0)}):(r.tracker.start(),r.isTracking=!0)),r}export{i as createWriteTrackSlate};

package/dist/tinymce/index.d.ts

@@ -0,0 +1,69 @@
+import { WriteTrack } from 'writetrack';
+
+export interface WriteTrackTinyMCEOptions {
+  /** WriteTrack license key */
+  license?: string;
+  /** User identifier for metadata */
+  userId?: string;
+  /** Content identifier for metadata */
+  contentId?: string;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+  /** Auto-start tracking when editor initializes (default: true) */
+  autoStart?: boolean;
+  /** URL to the WASM binary for analysis. If omitted, uses default loader path. */
+  wasmUrl?: string;
+  /** Enable IndexedDB session persistence and auto-resume. Requires contentId. */
+  persist?: boolean;
+}
+
+export interface WriteTrackTinyMCEHandle {
+  /** The underlying WriteTrack instance (null until editor init fires) */
+  tracker: WriteTrack | null;
+  /** Whether tracking is currently active */
+  isTracking: boolean;
+  /** Stop tracking and clean up resources */
+  destroy(): void;
+}
+
+/**
+ * Attach WriteTrack to a TinyMCE editor.
+ *
+ * Hooks into TinyMCE's `init` and `remove` lifecycle events.
+ * Uses `editor.getBody()` as the target element.
+ *
+ * **Note:** Only inline mode (`inline: true`) is fully supported.
+ * In iframe mode (default), window/document-level listeners attach to the
+ * host page rather than the iframe, resulting in degraded tracking.
+ *
+ * @example
+ * ```ts
+ * import tinymce from 'tinymce';
+ * import { createWriteTrackTinyMCE } from 'writetrack/tinymce';
+ *
+ * tinymce.init({
+ *   selector: '#editor',
+ *   inline: true,
+ *   setup: (editor) => {
+ *     const handle = createWriteTrackTinyMCE(editor, {
+ *       license: 'your-license-key',
+ *     });
+ *   },
+ * });
+ * ```
+ *
+ * @param editor - A TinyMCE `Editor` instance
+ * @param options - WriteTrack configuration options
+ * @returns A handle with the tracker instance and a destroy method
+ */
+export declare function createWriteTrackTinyMCE(
+  editor: {
+    getBody(): HTMLElement;
+    selection: {
+      getRng(): { startOffset: number };
+    };
+    on(event: string, handler: () => void): void;
+    off(event: string, handler: () => void): void;
+  },
+  options: WriteTrackTinyMCEOptions
+): WriteTrackTinyMCEHandle;

package/dist/tinymce/index.js

@@ -0,0 +1 @@
+import{WriteTrack as s}from"writetrack";function o(t,e){let i=e.autoStart!==!1,r={tracker:null,isTracking:!1,destroy(){r.tracker&&(r.tracker.stop(),r.tracker=null,r.isTracking=!1),t.off("init",n),t.off("remove",a)}};function n(){let c=t.getBody();r.tracker=new s({target:c,license:e.license,userId:e.userId,contentId:e.contentId,metadata:e.metadata,wasmUrl:e.wasmUrl,persist:e.persist,cursorPositionProvider:()=>{try{return t.selection.getRng().startOffset}catch{return 0}}}),i&&(e.persist?r.tracker.ready.then(()=>{r.tracker&&(r.tracker.start(),r.isTracking=!0)}):(r.tracker.start(),r.isTracking=!0))}function a(){r.destroy()}return t.on("init",n),t.on("remove",a),r}export{o as createWriteTrackTinyMCE};