@flowgram.ai/export-plugin 1.0.6

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import * as _flowgram_ai_core from '@flowgram.ai/core';
+import * as _flowgram_ai_utils from '@flowgram.ai/utils';
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+declare enum FlowDownloadFormat {
+    JSON = "json",
+    YAML = "yaml",
+    PNG = "png",
+    JPEG = "jpeg",
+    SVG = "svg"
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface WorkflowDownloadParams {
+    format: FlowDownloadFormat;
+}
+interface DownloadServiceOptions {
+    getFilename?: (format: FlowDownloadFormat) => string;
+    watermarkSVG?: string;
+}
+
+declare class FlowDownloadService {
+    private readonly document;
+    private readonly exportImageService;
+    private toDispose;
+    downloading: boolean;
+    private onDownloadingChangeEmitter;
+    private options;
+    onDownloadingChange: _flowgram_ai_utils.Event<boolean>;
+    init(options?: Partial<DownloadServiceOptions>): void;
+    dispose(): void;
+    download(params: WorkflowDownloadParams): Promise<void>;
+    setDownloading(value: boolean): void;
+    private handleImageDownload;
+    private handleDataDownload;
+    private downloadData;
+    private formatDataContent;
+    private downloadImage;
+    private getFileName;
+    private downloadFile;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+interface CreateDownloadPluginOptions extends Partial<DownloadServiceOptions> {
+}
+
+declare const createDownloadPlugin: _flowgram_ai_core.PluginCreator<CreateDownloadPluginOptions>;
+
+export { type CreateDownloadPluginOptions, type DownloadServiceOptions, FlowDownloadFormat, FlowDownloadService, createDownloadPlugin };

package/dist/index.js

@@ -0,0 +1,537 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlowDownloadFormat: () => FlowDownloadFormat,
+  FlowDownloadService: () => FlowDownloadService,
+  createDownloadPlugin: () => createDownloadPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/create-plugin.ts
+var import_core2 = require("@flowgram.ai/core");
+
+// src/export-image-service/service.ts
+var import_inversify = require("inversify");
+var import_document = require("@flowgram.ai/document");
+
+// src/export-image-service/utils.ts
+var import_core = require("@flowgram.ai/core");
+var getNodesRect = (nodes) => {
+  const rects = nodes.map((node) => node.getData(import_core.TransformData)?.bounds).filter(Boolean);
+  const x1 = Math.min(...rects.map((rect) => rect.x));
+  const x2 = Math.max(...rects.map((rect) => rect.x + rect.width));
+  const y1 = Math.min(...rects.map((rect) => rect.y));
+  const y2 = Math.max(...rects.map((rect) => rect.y + rect.height));
+  const width = x2 - x1;
+  const height = y2 - y1;
+  return {
+    width,
+    height,
+    x: x1,
+    y: y1
+  };
+};
+var getWorkflowRect = (document2) => getNodesRect(document2.getAllNodes());
+
+// src/export-image-service/constant.ts
+var USER_AGENT = navigator?.userAgent ?? "";
+var IN_CHROME = USER_AGENT.includes("Chrome");
+var IN_SAFARI = USER_AGENT.includes("AppleWebKit") && !IN_CHROME;
+var IN_FIREFOX = USER_AGENT.includes("Firefox");
+var EXPORT_IMAGE_WATERMARK_SVG = `
+<svg width="201" height="133" viewBox="0 0 201 133" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <image id="-" x="0" y="0" width="200" height="133" xlink:href="data:image/png;base64, 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"/>
+</svg>
+`;
+var EXPORT_IMAGE_STYLE_PROPERTIES = [
+  "width",
+  "height",
+  "box-sizing",
+  "display",
+  "align-items",
+  "justify-content",
+  "font-size",
+  "gap",
+  "color",
+  "background",
+  "background-color",
+  "font",
+  "font-family",
+  "fill",
+  "stroke",
+  "stroke-width",
+  "margin",
+  "padding",
+  "padding-left",
+  "padding-top",
+  "padding-bottom",
+  "padding-right",
+  "flex-direction",
+  "filter",
+  "position",
+  "top",
+  "left",
+  "bottom",
+  "right",
+  "content",
+  "line-height",
+  "text-decoration",
+  "border-radius",
+  "opacity",
+  "border-right",
+  "border-left",
+  "border-width",
+  "border-style",
+  "border-color",
+  "margin-right",
+  "margin-left",
+  "margin-top",
+  "margin-bottom",
+  "white-space",
+  "overflow",
+  "text-overflow",
+  "font-weight",
+  "min-width",
+  "min-height",
+  "transform",
+  "z-index",
+  "flex",
+  "border-width",
+  "text-wrap",
+  "word-break",
+  "vertical-align",
+  "aspect-ratio",
+  "object-fit",
+  "align-content",
+  "align-self",
+  "background-attachment",
+  "background-clip",
+  "background-image",
+  "background-origin",
+  "background-repeat",
+  "background-size",
+  "block-size",
+  "border-block-end-color",
+  "border-block-end-style",
+  "border-block-end-width",
+  "border-block-start-color",
+  "border-block-start-style",
+  "border-block-start-width",
+  "border-bottom-color",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-end-end-radius",
+  "border-end-start-radius",
+  "border-inline-end-color",
+  "border-inline-end-style",
+  "border-inline-end-width",
+  "border-inline-start-color",
+  "border-inline-start-style",
+  "border-inline-start-width",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-start-end-radius",
+  "border-start-start-radius",
+  "border-top-color",
+  "border-top-style",
+  "border-top-width",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "flex-basis",
+  "flex-grow",
+  "flex-shrink",
+  "flex-wrap",
+  "font-kerning",
+  "font-palette",
+  "font-stretch",
+  "font-style",
+  "inline-size",
+  "inset-block-end",
+  "inset-block-start",
+  "inset-inline-end",
+  "inset-inline-start",
+  "justify-items",
+  "justify-self",
+  "line-break",
+  "margin-trim",
+  "margin-inline-end",
+  "margin-inline-start",
+  "min-block-size",
+  "min-inline-size",
+  "overflow-wrap",
+  "overflow-x",
+  "overflow-y",
+  "perspective-origin",
+  "transform-box",
+  "transform-origin",
+  "transform-style",
+  "grid-template",
+  "grid-template-rows",
+  "grid-template-columns",
+  "grid-template-areas"
+];
+
+// src/constant.ts
+var FlowDownloadFormat = /* @__PURE__ */ ((FlowDownloadFormat2) => {
+  FlowDownloadFormat2["JSON"] = "json";
+  FlowDownloadFormat2["YAML"] = "yaml";
+  FlowDownloadFormat2["PNG"] = "png";
+  FlowDownloadFormat2["JPEG"] = "jpeg";
+  FlowDownloadFormat2["SVG"] = "svg";
+  return FlowDownloadFormat2;
+})(FlowDownloadFormat || {});
+var FlowImageFormats = [
+  "png" /* PNG */,
+  "jpeg" /* JPEG */,
+  "svg" /* SVG */
+];
+var FlowDataFormats = ["json" /* JSON */, "yaml" /* YAML */];
+
+// src/export-image-service/service.ts
+var PADDING_X = 58;
+var PADDING_Y = 138;
+var FlowExportImageService = class {
+  async export(options) {
+    try {
+      const imgUrl = await this.doExport(options);
+      return imgUrl;
+    } catch (e) {
+      console.error("Export image failed:", e);
+      return;
+    }
+  }
+  async loadModernScreenshot() {
+    if (this.modernScreenshot) {
+      return this.modernScreenshot;
+    }
+    const modernScreenshot = await import("modern-screenshot");
+    this.modernScreenshot = modernScreenshot;
+  }
+  async doExport(exportOptions) {
+    if (this.document.layout.name.includes("fixed-layout")) {
+      return await this.doFixedExport(exportOptions);
+    }
+    return await this.doFreeExport(exportOptions);
+  }
+  async doFreeExport(exportOptions) {
+    const { format } = exportOptions;
+    const renderLayer = window.document.querySelector(".gedit-flow-render-layer");
+    if (!renderLayer) {
+      return;
+    }
+    const { width, height, x, y } = getWorkflowRect(this.document);
+    await this.loadModernScreenshot();
+    const { domToPng, domToForeignObjectSvg, domToJpeg } = this.modernScreenshot;
+    let imgUrl;
+    const options = {
+      scale: 2,
+      includeStyleProperties: IN_SAFARI || IN_FIREFOX ? EXPORT_IMAGE_STYLE_PROPERTIES : void 0,
+      width: width + PADDING_X * 2,
+      height: height + PADDING_Y * 2,
+      onCloneEachNode: (cloned) => {
+        this.handleFreeClone(cloned, { width, height, x, y, options: exportOptions });
+      }
+    };
+    switch (format) {
+      case "png" /* PNG */:
+        imgUrl = await domToPng(renderLayer, options);
+        break;
+      case "svg" /* SVG */: {
+        const svg = await domToForeignObjectSvg(renderLayer, options);
+        imgUrl = await this.svgToDataURL(svg);
+        break;
+      }
+      case "jpeg" /* JPEG */:
+        imgUrl = await domToJpeg(renderLayer, options);
+        break;
+      default:
+        imgUrl = await domToPng(renderLayer, options);
+    }
+    return imgUrl;
+  }
+  async doFixedExport(exportOptions) {
+    const { format } = exportOptions;
+    const el = window.document.querySelector(".gedit-flow-nodes-layer");
+    if (!el) {
+      return;
+    }
+    const { width, height, x, y } = getWorkflowRect(this.document);
+    await this.loadModernScreenshot();
+    const { domToPng, domToForeignObjectSvg, domToJpeg } = this.modernScreenshot;
+    let imgUrl;
+    const options = {
+      scale: 2,
+      includeStyleProperties: IN_SAFARI || IN_FIREFOX ? EXPORT_IMAGE_STYLE_PROPERTIES : void 0,
+      width: width + PADDING_X * 2,
+      height: height + PADDING_Y * 2,
+      onCloneEachNode: (cloned) => {
+        this.handleFixedClone(cloned, { width, height, x, y, options: exportOptions });
+      }
+    };
+    switch (format) {
+      case "png" /* PNG */:
+        imgUrl = await domToPng(el, options);
+        break;
+      case "svg" /* SVG */: {
+        const svg = await domToForeignObjectSvg(el, options);
+        imgUrl = await this.svgToDataURL(svg);
+        break;
+      }
+      case "jpeg" /* JPEG */:
+        imgUrl = await domToJpeg(el, options);
+        break;
+      default:
+        imgUrl = await domToPng(el, options);
+    }
+    return imgUrl;
+  }
+  async svgToDataURL(svg) {
+    return Promise.resolve().then(() => new XMLSerializer().serializeToString(svg)).then(encodeURIComponent).then((html) => `data:image/svg+xml;charset=utf-8,${html}`);
+  }
+  // 处理克隆节点
+  handleFreeClone(cloned, {
+    width,
+    height,
+    x,
+    y,
+    options
+  }) {
+    if (cloned?.classList?.contains("gedit-flow-activity-node") || cloned?.classList?.contains("gedit-flow-activity-line")) {
+      this.handlePosition(cloned, x, y);
+    }
+    if (cloned?.classList?.contains("gedit-flow-render-layer")) {
+      this.handleCanvas(cloned, width, height, options);
+    }
+  }
+  // 处理克隆节点
+  handleFixedClone(cloned, {
+    width,
+    height,
+    x,
+    y,
+    options
+  }) {
+    if (cloned?.classList?.contains("gedit-flow-activity-node") || cloned?.classList?.contains("gedit-flow-activity-line")) {
+      this.handlePosition(cloned, x, y);
+    }
+    if (cloned?.classList?.contains("gedit-flow-nodes-layer")) {
+      const linesLayer = window.document.querySelector(".gedit-flow-lines-layer")?.cloneNode(true);
+      this.handleLines(linesLayer, width, height);
+      cloned.appendChild(linesLayer);
+      this.handleCanvas(cloned, width, height, options);
+    }
+  }
+  // 处理节点位置
+  handlePosition(cloned, x, y) {
+    cloned.style.transform = `translate(${-x + PADDING_X}px, ${-y + PADDING_Y}px)`;
+  }
+  // 处理画布
+  handleLines(cloned, width, height) {
+    cloned.style.position = "absolute";
+    cloned.style.width = `${width}px`;
+    cloned.style.height = `${height}px`;
+    cloned.style.left = `${width / 2 - PADDING_X}px`;
+    cloned.style.top = `${PADDING_Y}px`;
+    cloned.style.transform = "none";
+    cloned.style.backgroundColor = "transparent";
+    cloned.querySelector(".flow-lines-container").setAttribute("viewBox", `0 0 1000 1000`);
+  }
+  // 处理画布
+  handleCanvas(cloned, width, height, options) {
+    cloned.style.width = `${width + PADDING_X * 2}px`;
+    cloned.style.height = `${height + PADDING_Y * 2}px`;
+    cloned.style.transform = "none";
+    cloned.style.backgroundColor = "#ECECEE";
+    this.handleWaterMark(cloned, options);
+  }
+  // 添加水印节点
+  handleWaterMark(element, options) {
+    const watermarkNode = document.createElement("div");
+    watermarkNode.innerHTML = options?.watermarkSVG ?? EXPORT_IMAGE_WATERMARK_SVG;
+    watermarkNode.style.position = "absolute";
+    watermarkNode.style.bottom = "32px";
+    watermarkNode.style.right = "32px";
+    watermarkNode.style.zIndex = "999999";
+    element.appendChild(watermarkNode);
+  }
+};
+__decorateClass([
+  (0, import_inversify.inject)(import_document.FlowDocument)
+], FlowExportImageService.prototype, "document", 2);
+FlowExportImageService = __decorateClass([
+  (0, import_inversify.injectable)()
+], FlowExportImageService);
+
+// src/download-service/service.ts
+var import_nanoid = require("nanoid");
+var import_inversify2 = require("inversify");
+var import_utils2 = require("@flowgram.ai/utils");
+var import_document2 = require("@flowgram.ai/document");
+var FlowDownloadService = class {
+  constructor() {
+    this.toDispose = new import_utils2.DisposableCollection();
+    this.downloading = false;
+    this.onDownloadingChangeEmitter = new import_utils2.Emitter();
+    this.options = {};
+    this.onDownloadingChange = this.onDownloadingChangeEmitter.event;
+  }
+  init(options) {
+    this.options = options ?? {};
+    this.toDispose.push(this.onDownloadingChangeEmitter);
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  async download(params) {
+    if (this.downloading) {
+      return;
+    }
+    const { format } = params;
+    if (FlowImageFormats.includes(format)) {
+      await this.handleImageDownload(format);
+    } else if (FlowDataFormats.includes(format)) {
+      await this.handleDataDownload(format);
+    }
+  }
+  setDownloading(value) {
+    this.downloading = value;
+    this.onDownloadingChangeEmitter.fire(value);
+  }
+  async handleImageDownload(format) {
+    this.setDownloading(true);
+    try {
+      await this.downloadImage(format);
+    } finally {
+      this.setDownloading(false);
+    }
+  }
+  async handleDataDownload(format) {
+    this.setDownloading(true);
+    try {
+      await this.downloadData(format);
+    } finally {
+      this.setDownloading(false);
+    }
+  }
+  async downloadData(format) {
+    const json = this.document.toJSON();
+    const { content, mimeType } = await this.formatDataContent(json, format);
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const filename = this.getFileName(format);
+    this.downloadFile(url, filename);
+    URL.revokeObjectURL(url);
+  }
+  async formatDataContent(json, format) {
+    if (format === "yaml" /* YAML */) {
+      const yaml = await import("js-yaml");
+      return {
+        content: yaml.dump(json, {
+          indent: 2,
+          lineWidth: -1,
+          noRefs: true
+        }),
+        mimeType: "application/x-yaml"
+      };
+    }
+    return {
+      content: JSON.stringify(json, null, 2),
+      mimeType: "application/json"
+    };
+  }
+  async downloadImage(format) {
+    const imageUrl = await this.exportImageService.export({
+      format,
+      watermarkSVG: this.options.watermarkSVG
+    });
+    if (!imageUrl) {
+      return;
+    }
+    const filename = this.getFileName(format);
+    this.downloadFile(imageUrl, filename);
+  }
+  getFileName(format) {
+    if (this.options.getFilename) {
+      return this.options.getFilename(format);
+    }
+    return `flowgram-${(0, import_nanoid.nanoid)(5)}.${format}`;
+  }
+  downloadFile(href, filename) {
+    const link = document.createElement("a");
+    link.href = href;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+};
+__decorateClass([
+  (0, import_inversify2.inject)(import_document2.FlowDocument)
+], FlowDownloadService.prototype, "document", 2);
+__decorateClass([
+  (0, import_inversify2.inject)(FlowExportImageService)
+], FlowDownloadService.prototype, "exportImageService", 2);
+FlowDownloadService = __decorateClass([
+  (0, import_inversify2.injectable)()
+], FlowDownloadService);
+
+// src/create-plugin.ts
+var createDownloadPlugin = (0, import_core2.definePluginCreator)({
+  onBind: ({ bind }) => {
+    bind(FlowExportImageService).toSelf().inSingletonScope();
+    bind(FlowDownloadService).toSelf().inSingletonScope();
+  },
+  onInit: (ctx, opts) => {
+    ctx.get(FlowDownloadService).init(opts);
+  },
+  onDispose: (ctx) => {
+    ctx.get(FlowDownloadService).dispose();
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowDownloadFormat,
+  FlowDownloadService,
+  createDownloadPlugin
+});
+//# sourceMappingURL=index.js.map