@lofcz/pptist 2.0.20 → 2.0.22

package/dist/types/embed/mount.d.ts

@@ -1,5 +1,7 @@
 import 'prosemirror-view/style/prosemirror.css';
 import 'animate.css';
+import 'mathlive/static.css';
+import 'mathlive/fonts.css';
 import '../assets/styles/prosemirror.scss';
 import '../assets/styles/global.scss';
 import '../assets/styles/font.scss';

package/dist/types/i18n/i18n-types.d.ts

@@ -551,6 +551,20 @@ export type NamespaceComponentsTranslation = {
          */
         formulaEmpty: string;
     };
+    inlineMathEditor: {
+        /**
+         * E​d​i​t​ ​f​o​r​m​u​l​a
+         */
+        title: string;
+        /**
+         * E​n​t​e​r​ ​a​ ​f​o​r​m​u​l​a
+         */
+        inputPlaceholder: string;
+        /**
+         * F​o​r​m​u​l​a​ ​c​a​n​n​o​t​ ​b​e​ ​e​m​p​t​y
+         */
+        empty: string;
+    };
 };
 export type NamespaceConfigsTranslation = {
     shapes: {
@@ -5144,6 +5158,20 @@ export type TranslationFunctions = {
              */
             formulaEmpty: () => LocalizedString;
         };
+        inlineMathEditor: {
+            /**
+             * Edit formula
+             */
+            title: () => LocalizedString;
+            /**
+             * Enter a formula
+             */
+            inputPlaceholder: () => LocalizedString;
+            /**
+             * Formula cannot be empty
+             */
+            empty: () => LocalizedString;
+        };
     };
     configs: {
         shapes: {

package/dist/types/main.d.ts

@@ -1,5 +1,7 @@
 import 'prosemirror-view/style/prosemirror.css';
 import 'animate.css';
+import 'mathlive/static.css';
+import 'mathlive/fonts.css';
 import './assets/styles/prosemirror.scss';
 import './assets/styles/global.scss';
 import './assets/styles/font.scss';

package/dist/types/utils/emitter.d.ts

@@ -4,7 +4,9 @@ export declare const enum EmitterEvents {
     TABLE_COMMAND = "TABLE_COMMAND",
     SYNC_RICH_TEXT_ATTRS_TO_STORE = "SYNC_RICH_TEXT_ATTRS_TO_STORE",
     OPEN_CHART_DATA_EDITOR = "OPEN_CHART_DATA_EDITOR",
-    OPEN_LATEX_EDITOR = "OPEN_LATEX_EDITOR"
+    OPEN_LATEX_EDITOR = "OPEN_LATEX_EDITOR",
+    OPEN_INLINE_MATH_EDITOR = "OPEN_INLINE_MATH_EDITOR",
+    APPLY_INLINE_MATH = "APPLY_INLINE_MATH"
 }
 export interface RichTextAction {
     command: string;
@@ -19,12 +21,30 @@ export interface TableCommand {
     command: 'insert-row' | 'insert-col' | 'delete-row' | 'delete-col';
     position?: 'before' | 'after';
 }
+/** Request to open the inline-math (MathLive) editor for a math node in a text element. */
+export interface OpenInlineMathPayload {
+    elementId: string;
+    /** Document position immediately before the math node (for `setNodeMarkup`). */
+    pos: number;
+    latex: string;
+    display: boolean;
+}
+/** Result of editing an inline-math node, applied back to its text element. */
+export interface ApplyInlineMathPayload {
+    elementId: string;
+    pos: number;
+    latex: string;
+    html: string;
+    display: boolean;
+}
 type Events = {
     [EmitterEvents.RICH_TEXT_COMMAND]: RichTextCommand;
     [EmitterEvents.TABLE_COMMAND]: TableCommand;
     [EmitterEvents.SYNC_RICH_TEXT_ATTRS_TO_STORE]: void;
     [EmitterEvents.OPEN_CHART_DATA_EDITOR]: void;
     [EmitterEvents.OPEN_LATEX_EDITOR]: void;
+    [EmitterEvents.OPEN_INLINE_MATH_EDITOR]: OpenInlineMathPayload;
+    [EmitterEvents.APPLY_INLINE_MATH]: ApplyInlineMathPayload;
 };
 declare const emitter: Emitter<Events>;
 export default emitter;

package/dist/types/utils/katex-stub.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stub that replaces the real `katex` package at build time.
+ *
+ * `markdown-it-texmath` contains a static `require('katex')` fallback that the
+ * bundler must resolve even though PPTist always passes a MathLive `engine`
+ * adapter (see `utils/math.ts`), so that branch is never executed. Aliasing
+ * `katex` to this stub (in `vite.config.ts` / `vite.config.embed.ts`) lets us
+ * drop the real ~280KB KaTeX dependency while keeping the require resolvable.
+ */
+declare function renderToString(): string;
+export { renderToString };
+declare const _default: {
+    renderToString: typeof renderToString;
+};
+export default _default;

package/dist/types/utils/markdown.d.ts

@@ -25,7 +25,7 @@ export declare function tokenizeMath(source: string): ContentSegment[];
 export declare function splitLinesPreservingMath(value: string): string[];
 export declare function markdownToHtml(markdown: string): Promise<string>;
 /**
- * Preload the math-capable markdown parser (lazy KaTeX + texmath) so
+ * Preload the math-capable markdown parser (lazy MathLive + texmath) so
  * `renderInlineMarkdown` can render `$…$` math synchronously afterwards. No-op
  * once loaded; call before rendering content that may contain math.
  */

package/dist/types/utils/math.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared MathLive typesetting helpers.
+ *
+ * LaTeX is the single source of truth for in-text math. It is carried on a
+ * canonical wrapper element:
+ *
+ *   <span class="pptist-math" data-latex="\frac{1}{2}" data-display="false">…markup…</span>
+ *
+ * The inner markup is MathLive's `convertLatexToMarkup` output, preserved in the
+ * stored HTML so the static render paths (`v-html`) and ProseMirror round-trips
+ * never need to re-typeset existing content. MathLive itself is lazy-loaded the
+ * first time math actually appears (or the editor opens), so decks without math
+ * never pull it into the bundle. Static styling comes from `mathlive/static.css`
+ * + `mathlive/fonts.css`, imported once at app/embed bootstrap.
+ */
+export declare const MATH_CLASS = "pptist-math";
+type ConvertLatexToMarkup = (latex: string, options?: {
+    defaultMode?: 'inline-math' | 'math' | 'text';
+}) => string;
+interface MathliveModule {
+    convertLatexToMarkup: ConvertLatexToMarkup;
+    MathfieldElement: {
+        fontsDirectory: string | null;
+        soundsDirectory: string | null;
+    };
+}
+/**
+ * Reactive flag flipped to `true` once MathLive has loaded. Reading it inside a
+ * render (e.g. table `formatText`) registers a dependency so the math re-renders
+ * the moment the engine becomes available.
+ */
+export declare const mathReady: import("vue").Ref<boolean, boolean>;
+/** Lazily import MathLive and configure it for a bundled (offline) font setup. */
+export declare function ensureMathliveReady(): Promise<MathliveModule>;
+/** Escape a string for safe inclusion in a double-quoted HTML attribute. */
+export declare function escapeLatexAttr(latex: string): string;
+/**
+ * Render `latex` to the canonical `span.pptist-math` wrapper HTML string. Must
+ * only be called once {@link ensureMathliveReady} has resolved (the markdown
+ * pipeline and editor await it; tables fall back to literal source until ready).
+ */
+export declare function renderMathToHtml(latex: string, display?: boolean): string;
+/**
+ * Build a real `span.pptist-math` DOM node for the given latex/markup. Used by
+ * the ProseMirror schema `toDOM` so the editor DOM (and the innerHTML persisted
+ * on edit) is the same canonical wrapper the parser reads back.
+ */
+export declare function buildMathElement(latex: string, html: string, display?: boolean): HTMLSpanElement;
+/** Engine adapter that lets `markdown-it-texmath` typeset via MathLive. */
+export declare const texmathEngine: {
+    renderToString(latex: string, options?: {
+        displayMode?: boolean;
+    }): string;
+};
+/** True when an HTML string already contains rendered/wrapped math. */
+export declare function htmlContainsMath(html: string): boolean;
+export {};

package/dist/types/utils/prosemirror/schema/index.d.ts

@@ -3,6 +3,7 @@ export declare const schemaNodes: {
     paragraph: import("prosemirror-model").NodeSpec;
     blockquote: import("prosemirror-model").NodeSpec;
     text: import("prosemirror-model").NodeSpec;
+    math: import("prosemirror-model").NodeSpec;
     ordered_list: import("prosemirror-model").NodeSpec;
     bullet_list: import("prosemirror-model").NodeSpec;
     list_item: import("prosemirror-model").NodeSpec;

package/dist/types/utils/prosemirror/schema/nodes.d.ts

@@ -4,6 +4,7 @@ declare const _default: {
     paragraph: NodeSpec;
     blockquote: NodeSpec;
     text: NodeSpec;
+    math: NodeSpec;
     ordered_list: NodeSpec;
     bullet_list: NodeSpec;
     list_item: NodeSpec;

package/dist/types/utils/textFit.d.ts

@@ -0,0 +1,76 @@
+/** ProseMirror's default text size (assets/styles/prosemirror.scss). */
+export declare const DEFAULT_TEXT_FONT_SIZE = 16;
+/** Horizontal space a list marker + indent steals from a bullet's text column. */
+export declare const BULLET_INDENT = 28;
+/** A single measurable text block (one paragraph or one list item). */
+export interface TextFitBlock {
+    /** Plain text of the block (markers stripped). */
+    text: string;
+    /** Authored font size in px (its largest run, to stay safe). */
+    size: number;
+    bold?: boolean;
+    italic?: boolean;
+    fontFamily: string;
+    /** When true, a list marker indent is subtracted from the text column. */
+    listItem?: boolean;
+}
+export interface MeasureBlocksOptions {
+    /** Box content width in px (insets already removed). */
+    innerWidth: number;
+    /** Line height multiplier (e.g. 1.5). */
+    lineHeight: number;
+    /** Vertical gap added between consecutive blocks, in px (NOT scaled by sizeScale). */
+    blockSpace?: number;
+    /** Indent subtracted from the text column for list items, in px. */
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Multiply every block's font size by this factor before measuring (default 1). */
+    sizeScale?: number;
+}
+/**
+ * Total wrapped height (px) of `blocks` laid out in a column of `innerWidth`,
+ * with each block's font size multiplied by `sizeScale`. Each block is measured
+ * independently with pretext, then summed with the (unscaled, px-fixed)
+ * inter-block gap. Returns 0 for an empty input.
+ */
+export declare function measureTextBlocksHeight(blocks: TextFitBlock[], options: MeasureBlocksOptions): number;
+export interface FitFontScaleOptions {
+    innerWidth: number;
+    innerHeight: number;
+    lineHeight: number;
+    blockSpace?: number;
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Smallest font factor to fall back to before clipping takes over (default 0.1). */
+    minScale?: number;
+}
+/**
+ * Largest uniform font factor in `[minScale, 1]` at which `blocks` fit
+ * `innerHeight`, found by binary search over pretext measurements. The factor
+ * multiplies the authored font sizes; because wrapping changes as the type
+ * shrinks, this re-measures at each candidate (not a single geometric divide).
+ * Returns 1 when content already fits (or measurement isn't possible).
+ */
+export declare function fitFontScaleForBlocks(blocks: TextFitBlock[], options: FitFontScaleOptions): number;
+export interface ExtractedContent {
+    blocks: TextFitBlock[];
+}
+export interface ExtractOptions {
+    defaultFontFamily: string;
+    defaultSize?: number;
+}
+/**
+ * Parse a PPTist rich-text HTML string into measurable blocks. Each list item
+ * and top-level paragraph/quote becomes one block; a block's representative font
+ * size is the largest inline size in it (so measurement never under-estimates).
+ * Returns no blocks when there's no DOM parser or no text. List items are tagged
+ * so the marker indent is accounted for.
+ */
+export declare function extractFitBlocksFromHtml(html: string, options: ExtractOptions): ExtractedContent;
+/**
+ * Return a copy of `html` with every inline `font-size:Npx` multiplied by
+ * `scale` (rounded to 0.1px). Text without an explicit size is untouched here —
+ * the renderer scales that through the `--text-fit-base-size` CSS variable. A
+ * scale >= 1 (or a non-DOM context) returns the HTML unchanged.
+ */
+export declare function scaleHtmlFontSizes(html: string, scale: number): string;

package/dist/types/views/Editor/InlineMathEditorDialog.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/components/element/TableElement/utils.d.ts

@@ -8,4 +8,14 @@ export declare const getCellStyle: (outline: PPTElementOutline, style?: TableCel
  * Compute table cell text layout styles from optional cell style.
  */
 export declare const getTextStyle: (cellMinHeight: number, style?: TableCellStyle) => CSSProperties;
+/**
+ * Render a table cell's stored source for display. Plain text keeps the legacy
+ * newline/space escaping; cells whose source contains math (`$…$`, `$$…$$`,
+ * `\(…\)`, …) get each formula typeset with MathLive into the canonical
+ * `span.pptist-math` wrapper while the surrounding text stays escaped.
+ *
+ * Reads the reactive {@link mathReady} flag so the cell re-renders the moment
+ * MathLive finishes loading (kicked off lazily here on first math encounter);
+ * until then math segments fall back to their literal LaTeX source.
+ */
 export declare const formatText: (text: string) => string;

package/dist/types/views/components/element/hooks/useTextFit.d.ts

@@ -0,0 +1,22 @@
+import { type CSSProperties, type Ref } from 'vue';
+import type { PPTTextElement } from '../../../../types/slides';
+/**
+ * Auto-fit a fixed-size text box so its content never overflows — by computing a
+ * real font size with pretext, not a CSS transform.
+ *
+ * Only fixed-height (`fixedHeight`) boxes are constrained; normal boxes grow to
+ * fit. We measure the wrapped content with pretext (the same engine the agentic
+ * layout builder uses) and binary-search the largest uniform font factor at which
+ * it still fits. The renderer then applies that factor as actual font sizes:
+ *   - text with an explicit inline size renders from `fittedContent` (sizes
+ *     rewritten to `size * factor`);
+ *   - text using the default size shrinks via the `--text-fit-base-size` CSS
+ *     variable (the computed px value), since `.ProseMirror` hardcodes 16px.
+ * Vertical (top-to-bottom) text is left untouched.
+ */
+declare const _default: (elementInfo: Ref<PPTTextElement>) => {
+    fitScale: Ref<number, number>;
+    fittedContent: import("vue").ComputedRef<string>;
+    fitVars: import("vue").ComputedRef<CSSProperties>;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/pptist",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "description": "PPTist presentation editor embed bundle with a typed agentic bridge.",
   "type": "module",
   "main": "dist/embed/pptist-embed.js",
@@ -75,10 +75,10 @@
     "hfmath": "^0.0.2",
     "html-to-image": "^1.11.13",
     "jsonrepair": "^3.13.2",
-    "katex": "^0.17.0",
     "lodash": "^4.17.21",
     "markdown-it": "^14.2.0",
     "markdown-it-texmath": "^1.0.0",
+    "mathlive": "^0.110.0",
     "mitt": "^3.0.1",
     "nanoid": "^5.0.7",
     "number-precision": "^1.6.0",