@lofcz/pptist 2.0.20 → 2.0.21

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,73 @@
+/** 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;
+    /** Font size in px the block renders at (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. */
+    blockSpace?: number;
+    /** Indent subtracted from the text column for list items, in px. */
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Multiply every size + gap by this factor before measuring (default 1). */
+    scale?: number;
+}
+/**
+ * Total wrapped height (px) of `blocks` laid out in a column of `innerWidth`.
+ * Each block is measured independently with its own font, then summed with the
+ * inter-block gap. Returns 0 for an empty input.
+ */
+export declare function measureTextBlocksHeight(blocks: TextFitBlock[], options: MeasureBlocksOptions): number;
+export interface FitScaleOptions {
+    innerWidth: number;
+    innerHeight: number;
+    lineHeight: number;
+    blockSpace?: number;
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Smallest scale to fall back to before clipping takes over (default 0.2). */
+    minScale?: number;
+}
+/**
+ * Largest uniform scale in `[minScale, 1]` at which `blocks` fit `innerHeight`.
+ *
+ * The renderer applies the result as `transform: scale(s)`, which scales the
+ * already-wrapped block geometrically — so the on-screen height is exactly
+ * `naturalHeight * s`. That makes the fit a single measurement (no search):
+ * `s = innerHeight / naturalHeight`, clamped. Returns 1 when content already
+ * fits (or when measurement isn't possible).
+ */
+export declare function fitScaleForBlocks(blocks: TextFitBlock[], options: FitScaleOptions): number;
+export type TextFitAlign = 'left' | 'center' | 'right';
+export interface ExtractedContent {
+    blocks: TextFitBlock[];
+    /** Dominant horizontal alignment (first non-empty block), for the scale origin. */
+    align: TextFitAlign;
+}
+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;

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,18 @@
+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.
+ *
+ * Only fixed-height (`fixedHeight`) text boxes are constrained — they have a
+ * locked region instead of growing to fit. We measure the rendered content with
+ * pretext (the same engine the agentic layout builder uses) and return a uniform
+ * scale (<= 1) plus a transform-origin that respects the box's horizontal
+ * alignment and `vAlign`. The renderer applies these to the text node as a CSS
+ * transform, shrinking the type down from its authored size only as far as
+ * needed. Vertical (top-to-bottom) text is left unscaled.
+ */
+declare const _default: (elementInfo: Ref<PPTTextElement>) => {
+    fitScale: Ref<number, number>;
+    fitStyle: import("vue").ComputedRef<CSSProperties>;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/pptist",
-  "version": "2.0.20",
+  "version": "2.0.21",
   "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",