opentiny 6.9.0

package/src/core/main/ts/api/dom/TreeWalker.ts

@@ -0,0 +1,129 @@
+export interface DomTreeWalkerConstructor {
+  readonly prototype: DomTreeWalker;
+
+  new (startNode: Node, rootNode: Node): DomTreeWalker;
+}
+
+/**
+ * TreeWalker class enables you to walk the DOM in a linear manner.
+ *
+ * @class tinymce.dom.TreeWalker
+ * @example
+ * const walker = new tinymce.dom.TreeWalker(startNode);
+ *
+ * do {
+ *   console.log(walker.current());
+ * } while (walker.next());
+ */
+
+class DomTreeWalker {
+  private readonly rootNode: Node;
+  private node: Node | null | undefined;
+
+  public constructor(startNode: Node, rootNode: Node) {
+    this.node = startNode;
+    this.rootNode = rootNode;
+
+    // This is a bit hacky but needed to ensure the 'this' variable
+    // always references the instance and not the caller scope
+    this.current = this.current.bind(this);
+    this.next = this.next.bind(this);
+    this.prev = this.prev.bind(this);
+    this.prev2 = this.prev2.bind(this);
+  }
+
+  /**
+   * Returns the current node.
+   *
+   * @method current
+   * @return {Node/undefined} Current node where the walker is, or undefined if the walker has reached the end.
+   */
+  public current(): Node | null | undefined {
+    return this.node;
+  }
+
+  /**
+   * Walks to the next node in tree.
+   *
+   * @method next
+   * @return {Node/undefined} Current node where the walker is after moving to the next node, or undefined if the walker has reached the end.
+   */
+  public next(shallow?: boolean): Node | null | undefined {
+    this.node = this.findSibling(this.node, 'firstChild', 'nextSibling', shallow);
+    return this.node;
+  }
+
+  /**
+   * Walks to the previous node in tree.
+   *
+   * @method prev
+   * @return {Node/undefined} Current node where the walker is after moving to the previous node, or undefined if the walker has reached the end.
+   */
+  public prev(shallow?: boolean): Node | null | undefined {
+    this.node = this.findSibling(this.node, 'lastChild', 'previousSibling', shallow);
+    return this.node;
+  }
+
+  public prev2(shallow?: boolean): Node | null | undefined {
+    this.node = this.findPreviousNode(this.node, shallow);
+    return this.node;
+  }
+
+  private findSibling(node: Node | null | undefined, startName: 'firstChild' | 'lastChild', siblingName: 'nextSibling' | 'previousSibling', shallow?: boolean): Node | null | undefined {
+    if (node) {
+      // Walk into nodes if it has a start
+      if (!shallow && node[startName]) {
+        return node[startName];
+      }
+
+      // Return the sibling if it has one
+      if (node !== this.rootNode) {
+        let sibling = node[siblingName];
+        if (sibling) {
+          return sibling;
+        }
+
+        // Walk up the parents to look for siblings
+        for (let parent = node.parentNode; parent && parent !== this.rootNode; parent = parent.parentNode) {
+          sibling = parent[siblingName];
+          if (sibling) {
+            return sibling;
+          }
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  private findPreviousNode(node: Node | null | undefined, shallow?: boolean): Node | undefined {
+    if (node) {
+      const sibling = node.previousSibling;
+      if (this.rootNode && sibling === this.rootNode) {
+        return;
+      }
+
+      if (sibling) {
+        if (!shallow) {
+          // Walk down to the most distant child
+          for (let child = sibling.lastChild; child; child = child.lastChild) {
+            if (!child.lastChild) {
+              return child;
+            }
+          }
+        }
+
+        return sibling;
+      }
+
+      const parent = node.parentNode;
+      if (parent && parent !== this.rootNode) {
+        return parent;
+      }
+    }
+
+    return undefined;
+  }
+}
+
+export default DomTreeWalker;

package/src/core/main/ts/api/file/BlobCache.ts

@@ -0,0 +1,143 @@
+import { Arr, Fun, Type } from '@ephox/katamari';
+
+import * as Uuid from '../../util/Uuid';
+
+export interface BlobCache {
+  create: {
+    (o: BlobInfoData): BlobInfo;
+    (id: string, blob: Blob, base64: string, name?: string, filename?: string): BlobInfo;
+  };
+  add: (blobInfo: BlobInfo) => void;
+  get: (id: string) => BlobInfo | undefined;
+  getByUri: (blobUri: string) => BlobInfo | undefined;
+  getByData: (base64: string, type: string) => BlobInfo | undefined;
+  findFirst: (predicate: (blobInfo: BlobInfo) => boolean) => BlobInfo | undefined;
+  removeByUri: (blobUri: string) => void;
+  destroy: () => void;
+}
+
+export interface BlobInfoData {
+  id?: string;
+  name?: string;
+  filename?: string;
+  blob: Blob;
+  base64: string;
+  blobUri?: string;
+  uri?: string;
+}
+
+export interface BlobInfo {
+  id: () => string;
+  name: () => string;
+  filename: () => string;
+  blob: () => Blob;
+  base64: () => string;
+  blobUri: () => string;
+  uri: () => string | undefined;
+}
+
+export const BlobCache = (): BlobCache => {
+  let cache: BlobInfo[] = [];
+
+  const mimeToExt = (mime: string) => {
+    const mimes: Record<string, string> = {
+      'image/jpeg': 'jpg',
+      'image/jpg': 'jpg',
+      'image/gif': 'gif',
+      'image/png': 'png',
+      'image/apng': 'apng',
+      'image/avif': 'avif',
+      'image/svg+xml': 'svg',
+      'image/webp': 'webp',
+      'image/bmp': 'bmp',
+      'image/tiff': 'tiff'
+    };
+
+    return mimes[mime.toLowerCase()] || 'dat';
+  };
+
+  const create = (o: BlobInfoData | string, blob?: Blob, base64?: string, name?: string, filename?: string): BlobInfo => {
+    if (Type.isString(o)) {
+      const id = o;
+
+      return toBlobInfo({
+        id,
+        name,
+        filename,
+        blob: blob as Blob,
+        base64: base64 as string
+      });
+    } else if (Type.isObject(o)) {
+      return toBlobInfo(o);
+    } else {
+      throw new Error('Unknown input type');
+    }
+  };
+
+  const toBlobInfo = (o: BlobInfoData): BlobInfo => {
+    if (!o.blob || !o.base64) {
+      throw new Error('blob and base64 representations of the image are required for BlobInfo to be created');
+    }
+
+    const id = o.id || Uuid.uuid('blobid');
+    const name = o.name || id;
+    const blob = o.blob;
+
+    return {
+      id: Fun.constant(id),
+      name: Fun.constant(name),
+      filename: Fun.constant(o.filename || name + '.' + mimeToExt(blob.type)),
+      blob: Fun.constant(blob),
+      base64: Fun.constant(o.base64),
+      blobUri: Fun.constant(o.blobUri || URL.createObjectURL(blob)),
+      uri: Fun.constant(o.uri)
+    };
+  };
+
+  const add = (blobInfo: BlobInfo) => {
+    if (!get(blobInfo.id())) {
+      cache.push(blobInfo);
+    }
+  };
+
+  const findFirst = (predicate: (blobInfo: BlobInfo) => boolean) => Arr.find(cache, predicate).getOrUndefined();
+
+  const get = (id: string) =>
+    findFirst((cachedBlobInfo) => cachedBlobInfo.id() === id);
+
+  const getByUri = (blobUri: string) =>
+    findFirst((blobInfo) => blobInfo.blobUri() === blobUri);
+
+  const getByData = (base64: string, type: string) =>
+    findFirst((blobInfo) => blobInfo.base64() === base64 && blobInfo.blob().type === type);
+
+  const removeByUri = (blobUri: string) => {
+    cache = Arr.filter(cache, (blobInfo) => {
+      if (blobInfo.blobUri() === blobUri) {
+        URL.revokeObjectURL(blobInfo.blobUri());
+        return false;
+      }
+
+      return true;
+    });
+  };
+
+  const destroy = () => {
+    Arr.each(cache, (cachedBlobInfo) => {
+      URL.revokeObjectURL(cachedBlobInfo.blobUri());
+    });
+
+    cache = [];
+  };
+
+  return {
+    create,
+    add,
+    get,
+    getByUri,
+    getByData,
+    findFirst,
+    removeByUri,
+    destroy
+  };
+};

package/src/core/main/ts/api/fmt/Format.ts

@@ -0,0 +1,16 @@
+import {
+  ApplyFormat, BlockFormat, Format, Formats, InlineFormat, RemoveBlockFormat, RemoveFormat, RemoveInlineFormat, RemoveSelectorFormat, SelectorFormat
+} from '../../fmt/FormatTypes';
+
+export {
+  Formats,
+  Format,
+  ApplyFormat,
+  BlockFormat,
+  InlineFormat,
+  SelectorFormat,
+  RemoveFormat,
+  RemoveBlockFormat,
+  RemoveInlineFormat,
+  RemoveSelectorFormat
+};

package/src/core/main/ts/api/fmt/StyleFormat.ts

@@ -0,0 +1,30 @@
+import { BlockFormat, InlineFormat, SelectorFormat } from './Format';
+
+// somewhat documented at https://www.tiny.cloud/docs/tinymce/6/content-formatting/#formats
+export type StyleFormat = BlockStyleFormat | InlineStyleFormat | SelectorStyleFormat;
+export type AllowedFormat = Separator | FormatReference | StyleFormat | NestedFormatting;
+
+export interface Separator {
+  title: string;
+}
+
+export interface FormatReference {
+  title: string;
+  format: string;
+  icon?: string;
+}
+
+export interface NestedFormatting {
+  title: string;
+  items: Array<FormatReference | StyleFormat>;
+}
+
+interface CommonStyleFormat {
+  name?: string;
+  title: string;
+  icon?: string;
+}
+
+export interface BlockStyleFormat extends BlockFormat, CommonStyleFormat {}
+export interface InlineStyleFormat extends InlineFormat, CommonStyleFormat {}
+export interface SelectorStyleFormat extends SelectorFormat, CommonStyleFormat {}

package/src/core/main/ts/api/geom/Rect.ts

@@ -0,0 +1,210 @@
+/**
+ * Contains various tools for rect/position calculation.
+ *
+ * @class tinymce.geom.Rect
+ */
+
+export interface GeomRect {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+
+interface Rect {
+  inflate: (rect: GeomRect, w: number, h: number) => GeomRect;
+  relativePosition: (rect: GeomRect, targetRect: GeomRect, rel: string) => GeomRect;
+  findBestRelativePosition: (rect: GeomRect, targetRect: GeomRect, constrainRect: GeomRect, rels: string[]) => string | null;
+  intersect: (rect: GeomRect, cropRect: GeomRect) => GeomRect | null;
+  clamp: (rect: GeomRect, clampRect: GeomRect, fixedSize?: boolean) => GeomRect;
+  create: (x: number, y: number, w: number, h: number) => GeomRect;
+  fromClientRect: (clientRect: DOMRect) => GeomRect;
+}
+
+const min = Math.min, max = Math.max, round = Math.round;
+
+/**
+ * Returns the rect positioned based on the relative position name
+ * to the target rect.
+ *
+ * @method relativePosition
+ * @param {Rect} rect Source rect to modify into a new rect.
+ * @param {Rect} targetRect Rect to move relative to based on the rel option.
+ * @param {String} rel Relative position. For example: tr-bl.
+ */
+const relativePosition = (rect: GeomRect, targetRect: GeomRect, rel: string): GeomRect => {
+  let x = targetRect.x;
+  let y = targetRect.y;
+  const w = rect.w;
+  const h = rect.h;
+  const targetW = targetRect.w;
+  const targetH = targetRect.h;
+
+  const relChars = (rel || '').split('');
+
+  if (relChars[0] === 'b') {
+    y += targetH;
+  }
+
+  if (relChars[1] === 'r') {
+    x += targetW;
+  }
+
+  if (relChars[0] === 'c') {
+    y += round(targetH / 2);
+  }
+
+  if (relChars[1] === 'c') {
+    x += round(targetW / 2);
+  }
+
+  if (relChars[3] === 'b') {
+    y -= h;
+  }
+
+  if (relChars[4] === 'r') {
+    x -= w;
+  }
+
+  if (relChars[3] === 'c') {
+    y -= round(h / 2);
+  }
+
+  if (relChars[4] === 'c') {
+    x -= round(w / 2);
+  }
+
+  return create(x, y, w, h);
+};
+
+/**
+ * Tests various positions to get the most suitable one.
+ *
+ * @method findBestRelativePosition
+ * @param {Rect} rect Rect to use as source.
+ * @param {Rect} targetRect Rect to move relative to.
+ * @param {Rect} constrainRect Rect to constrain within.
+ * @param {Array} rels Array of relative positions to test against.
+ */
+const findBestRelativePosition = (rect: GeomRect, targetRect: GeomRect, constrainRect: GeomRect, rels: string[]): string | null => {
+  for (let i = 0; i < rels.length; i++) {
+    const pos = relativePosition(rect, targetRect, rels[i]);
+
+    if (pos.x >= constrainRect.x && pos.x + pos.w <= constrainRect.w + constrainRect.x &&
+      pos.y >= constrainRect.y && pos.y + pos.h <= constrainRect.h + constrainRect.y) {
+      return rels[i];
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Inflates the rect in all directions.
+ *
+ * @method inflate
+ * @param {Rect} rect Rect to expand.
+ * @param {Number} w Relative width to expand by.
+ * @param {Number} h Relative height to expand by.
+ * @return {Rect} New expanded rect.
+ */
+const inflate = (rect: GeomRect, w: number, h: number): GeomRect => {
+  return create(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);
+};
+
+/**
+ * Returns the intersection of the specified rectangles.
+ *
+ * @method intersect
+ * @param {Rect} rect The first rectangle to compare.
+ * @param {Rect} cropRect The second rectangle to compare.
+ * @return {Rect} The intersection of the two rectangles or null if they don't intersect.
+ */
+const intersect = (rect: GeomRect, cropRect: GeomRect): GeomRect | null => {
+  const x1 = max(rect.x, cropRect.x);
+  const y1 = max(rect.y, cropRect.y);
+  const x2 = min(rect.x + rect.w, cropRect.x + cropRect.w);
+  const y2 = min(rect.y + rect.h, cropRect.y + cropRect.h);
+
+  if (x2 - x1 < 0 || y2 - y1 < 0) {
+    return null;
+  }
+
+  return create(x1, y1, x2 - x1, y2 - y1);
+};
+
+/**
+ * Returns a rect clamped within the specified clamp rect. This forces the
+ * rect to be inside the clamp rect.
+ *
+ * @method clamp
+ * @param {Rect} rect Rectangle to force within clamp rect.
+ * @param {Rect} clampRect Rectable to force within.
+ * @param {Boolean} fixedSize True/false if size should be fixed.
+ * @return {Rect} Clamped rect.
+ */
+const clamp = (rect: GeomRect, clampRect: GeomRect, fixedSize?: boolean): GeomRect => {
+  let x1 = rect.x;
+  let y1 = rect.y;
+  let x2 = rect.x + rect.w;
+  let y2 = rect.y + rect.h;
+  const cx2 = clampRect.x + clampRect.w;
+  const cy2 = clampRect.y + clampRect.h;
+
+  const underflowX1 = max(0, clampRect.x - x1);
+  const underflowY1 = max(0, clampRect.y - y1);
+  const overflowX2 = max(0, x2 - cx2);
+  const overflowY2 = max(0, y2 - cy2);
+
+  x1 += underflowX1;
+  y1 += underflowY1;
+
+  if (fixedSize) {
+    x2 += underflowX1;
+    y2 += underflowY1;
+    x1 -= overflowX2;
+    y1 -= overflowY2;
+  }
+
+  x2 -= overflowX2;
+  y2 -= overflowY2;
+
+  return create(x1, y1, x2 - x1, y2 - y1);
+};
+
+/**
+ * Creates a new rectangle object.
+ *
+ * @method create
+ * @param {Number} x Rectangle x location.
+ * @param {Number} y Rectangle y location.
+ * @param {Number} w Rectangle width.
+ * @param {Number} h Rectangle height.
+ * @return {Rect} New rectangle object.
+ */
+const create = (x: number, y: number, w: number, h: number): GeomRect => {
+  return { x, y, w, h };
+};
+
+/**
+ * Creates a new rectangle object form a clientRects object.
+ *
+ * @method fromClientRect
+ * @param {ClientRect} clientRect DOM ClientRect object.
+ * @return {Rect} New rectangle object.
+ */
+const fromClientRect = (clientRect: DOMRect): GeomRect => {
+  return create(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
+};
+
+const Rect: Rect = {
+  inflate,
+  relativePosition,
+  findBestRelativePosition,
+  intersect,
+  clamp,
+  create,
+  fromClientRect
+};
+
+export default Rect;