fable-editor 1.2.7 → 1.3.0

package/dist/angular/core/editor.d.ts

@@ -17,7 +17,12 @@ export declare class FableEditor implements FableEditorApi {
     private foreColor;
     private backColor;
     private openPop;
-    private openSubEl;
+    /** Stack of currently-open flyout submenus, shallowest first (e.g. for
+     *  Table > Cell > Cell background: [Cell flyout, Cell background flyout]).
+     *  A single slot isn't enough past one level deep - opening a 2nd-level
+     *  flyout would remove the 1st-level one still needed to bridge visually
+     *  back to the top-level popup, leaving a gap. */
+    private subStack;
     private popAnchor;
     private dlgOvl;
     private tblActive;
@@ -118,6 +123,17 @@ export declare class FableEditor implements FableEditorApi {
     private scheduleDraftSave;
     private revisionDlg;
     private closeSub;
+    /** Removes stacked flyouts from `level` (0 = shallowest) onward, keeping
+     *  anything shallower - e.g. hovering a sibling item inside the "Cell"
+     *  flyout should drop a deeper "Cell background" flyout but keep "Cell"
+     *  itself and the top-level popup it bridges to. */
+    private closeSubFrom;
+    /** True if `node` is inside any currently-open flyout submenu (any depth). */
+    private subContains;
+    /** 0 for the top-level popup itself; otherwise this container's depth in
+     *  the flyout stack + 1. Used to know how many deeper flyouts to close
+     *  when opening or hovering within `container`. */
+    private subLevelOf;
     private closePop;
     private openSubFor;
     private popup;
@@ -244,6 +260,26 @@ export declare class FableEditor implements FableEditorApi {
      *  so apps can route the file to S3 / Azure Blob / their own server. */
     private uploadImageFile;
     private replacePlaceholderWithImage;
+    /** Width of the editor's text column — the width `.earea img { max-width:100% }`
+     *  clamps an oversized image to. */
+    private contentWidth;
+    /** Inserts an <img> through execCommand and stamps its size once it has decoded.
+     *  A throwaway id is the only way to get a handle on what insertHTML created. */
+    private insertImageHTML;
+    /** Gives a newly inserted image an explicit size so it renders the same in the
+     *  editor, in Preview and in a sent email. Without it the image only looks right
+     *  inside `.earea`, whose `max-width:100%` rule exists nowhere else — which is why
+     *  the same picture came out at a different size once the mail was sent.
+     *  Leaves alone: images inside a template media slot (deliberately fluid) and any
+     *  image that already carries a size from its source. */
+    private stampImageSize;
+    /** Sizes images in content that arrived from outside the editor — a document saved
+     *  before the editor started recording image sizes. Without this such a document
+     *  keeps rendering at one size here and another in a sent mail. Images that already
+     *  carry a size, and template slots, are left alone, so content written by a
+     *  current version passes through untouched. Emits one change after the images have
+     *  settled rather than one per image, and none at all if nothing needed stamping. */
+    private stampExistingImages;
     private positionImgPhCtx;
     private pickVideo;
     private vidPhHTML;
@@ -361,6 +397,20 @@ export declare class FableEditor implements FableEditorApi {
     private refreshState;
     private countWords;
     private handlePaste;
+    /** Rich-HTML paste. Before the (untouched) paste engine runs, pictures Word left
+     *  behind as unreadable file:// refs are pulled out of the clipboard's RTF flavor
+     *  and inlined — the same pairing TinyMCE PowerPaste does for
+     *  powerpaste_allow_local_images. Everything the engine already handled is
+     *  unaffected: with no RTF, or no recoverable picture, the HTML reaches it
+     *  byte-identical to before. */
+    private pasteRichHTML;
+    /** Hands recovered pictures to the host's imageUploadHandler when one is
+     *  configured (PowerPaste's automatic_uploads equivalent), then inserts. Without a
+     *  handler they stay inline base64, which is what PowerPaste does by default. */
+    private finishRichPaste;
+    /** `deferred` means the insert is happening after an async hop, so the caret the
+     *  paste started from has to be put back first. */
+    private insertPastedHTML;
     private initUI;
 }
 export default FableEditor;

package/dist/angular/core/word-image-paste.d.ts

@@ -0,0 +1,27 @@
+/** Decoded pictures in document order. A slot is null when the picture exists but
+ *  cannot be turned into something the browser can show (a true vector metafile). */
+export type RtfImages = (string | null)[];
+/** Every picture in the RTF flavor, in document order. */
+export declare function extractRtfImages(rtf: string): RtfImages;
+export interface InjectResult {
+    html: string;
+    /** The data URIs this call put into the HTML, in the order they were used. Only
+     *  these are candidates for the host's imageUploadHandler — data URIs that were
+     *  already in the pasted HTML are left alone, so existing paste behaviour is
+     *  unchanged. */
+    injected: string[];
+}
+/** Rewrites unusable <img src> values in raw pasted HTML with the pictures given, in
+ *  document order. Images that already have a usable src are left alone and do not
+ *  consume a slot, so a mixed paste (webmail image + Word image) stays aligned.
+ *  Anything without a matching picture keeps its original tag. */
+export declare function injectImages(html: string, imgs: RtfImages): InjectResult;
+/** Pairs the HTML flavor of a Word paste with the pictures in its RTF flavor. */
+export declare function injectRtfImages(html: string, rtf: string): InjectResult;
+/** True when the cleaned HTML still holds images the engine could not resolve — used
+ *  to decide whether a bitmap sitting in the clipboard is worth falling back to. */
+export declare function countUnresolvedImages(html: string): number;
+/** data: URI -> File, so recovered pictures can go through the host's
+ *  imageUploadHandler exactly like a picked file does. `baseName` gets the extension
+ *  that matches the URI's MIME type. */
+export declare function dataUrlToFile(dataUrl: string, baseName: string): File | null;