@servicetitan/dte-unlayer 0.153.0 → 0.155.0

package/src/tools.ts

@@ -1,5 +1,13 @@
-import { constGenericsEditor, UnlayerToolMetaData } from './shared/const';
+import {
+    constGenericsEditor,
+    E_SIGN_DATE_SIGNED_OFFSET_TYPE,
+    E_SIGN_DATE_SIGNED_OFFSET_VALUES_KEY,
+    E_SIGN_TOOL_SLUG,
+    UnlayerToolMetaData,
+} from './shared/const';
+import { isESignOffsetSettings, normalizeESignOffsetSettings } from './shared/e-sign-offset';
 import { editIconSvg } from './shared/edit-icon';
+import { generateInstanceId, INSTANCE_ID_TOOL_SLUGS } from './shared/instance-id';
 import { unlayerToolsParseUnitKey } from './shared/tools';
 import { versions } from './unlayer';
 
@@ -202,6 +210,84 @@ export const unlayerToolsListCustom = (design: UnlayerDesignFormat): UnlayerDesi
     return tools;
 };
 
+/**
+ * Makes `values.id` unique across all instance-id tools (see `INSTANCE_ID_TOOL_SLUGS`)
+ * in the design. Duplicating content/rows in Unlayer copies the values verbatim, so
+ * every copy ends up with the original's GUID; this gives each copy a fresh one.
+ *
+ * Of the contents sharing an id, the one that keeps it is the first in document
+ * order that is not the just-added content (`addedHtmlID`), so the original always
+ * wins over its duplicate regardless of where the copy was inserted.
+ *
+ * @returns `true` when at least one id was regenerated.
+ */
+export const unlayerToolsDedupeInstanceIds = (
+    design: UnlayerDesignFormat,
+    addedHtmlID?: string
+): boolean => {
+    const byId = new Map<string, UnlayerDesignCustomTool[]>();
+
+    unlayerToolsIterateCustom(design, tool => {
+        const id = tool.values?.id;
+
+        if (INSTANCE_ID_TOOL_SLUGS.includes(tool.slug) && typeof id === 'string' && id) {
+            const key = `${tool.slug}|${id}`;
+            byId.set(key, [...(byId.get(key) ?? []), tool]);
+        }
+    });
+
+    let hasChanges = false;
+
+    byId.forEach(tools => {
+        if (tools.length < 2) {
+            return;
+        }
+
+        const keeper = tools.find(tool => tool.values?._meta?.htmlID !== addedHtmlID) ?? tools[0];
+
+        for (const tool of tools) {
+            if (tool !== keeper) {
+                /*
+                 * If no id can be generated the copy is left without one, which is still
+                 * better than two instances bound to the same image.
+                 */
+                tool.values.id = generateInstanceId();
+                hasChanges = true;
+            }
+        }
+    });
+
+    return hasChanges;
+};
+
+/**
+ * Gives every "Date Signed Offset" e-sign placement valid settings. Unlayer never applies an
+ * option's default to placements saved before the option existed, and the backend rejects a
+ * design whose dateSignedOffset recipient has no settings.
+ */
+export const unlayerToolsNormalizeESignOffsets = (design: UnlayerDesignFormat): boolean => {
+    let hasChanges = false;
+
+    unlayerToolsIterateCustom(design, tool => {
+        if (
+            tool.slug !== E_SIGN_TOOL_SLUG ||
+            tool.values?.eSignFieldType !== E_SIGN_DATE_SIGNED_OFFSET_TYPE
+        ) {
+            return;
+        }
+
+        const settings = tool.values[E_SIGN_DATE_SIGNED_OFFSET_VALUES_KEY];
+
+        if (!isESignOffsetSettings(settings)) {
+            tool.values[E_SIGN_DATE_SIGNED_OFFSET_VALUES_KEY] =
+                normalizeESignOffsetSettings(settings);
+            hasChanges = true;
+        }
+    });
+
+    return hasChanges;
+};
+
 export const unlayerToolsBuildDesign = (tools: UnlayerDesignTool[]): UnlayerDesignFormat => {
     const design = unlayerGetDefaultDesign();
 

package/src/unlayer-interface.tsx

@@ -45,13 +45,23 @@ export interface UnlayerRef {
     sendFormList(forms: FormInfo[]): void;
     sendFormFields(formId: number, fields: FormFieldInfo[]): void;
     sendCalcFieldLabels(labels: Record<string, string>): void;
+    /**
+     * Replaces the editor's merge tag menu with `tags` (grouped). Safe to call before the editor is
+     * ready — the tags are applied once it is. Lets hosts add tags that finish loading after init
+     * (e.g. form fields) without remounting the editor.
+     */
+    setMergeTags(tags: UnlayerEditorMergeTagInfo[] | undefined): void;
 }
 
 export interface UnlayerEditorMergeTagInfo {
     id: string;
     name: string;
     propertyPath: string;
-    group?: string;
+    /**
+     * Submenu the tag is listed under. A string is a single submenu (`'Custom Fields'`);
+     * an array nests submenus in order (`['Forms', 'Customer Intake']` → Forms ▸ Customer Intake ▸ tag).
+     */
+    group?: string | string[];
 }
 
 export interface UnlayerEditorCustomTool {

package/src/unlayer.tsx

@@ -1,7 +1,7 @@
 import { emitDisplayCondition } from './display-conditions/displayConditionController';
 import { editorCoreScript, editorCoreStyles, editorCoreTools } from './editor-core';
 import { logUnlayerError } from './log';
-import { scheduleUnlayerMergeTags, toUnlayerMergeTags } from './merge-tags';
+import { toUnlayerMergeTags } from './merge-tags';
 import { constGenericsEditor } from './shared/const';
 import { unlayerSupportedFonts } from './shared/fonts';
 import {
@@ -299,6 +299,10 @@ export const createUnlayerEditor = (
                     tables: true,
                 },
             },
+            /*
+             * Flat only: nested groups here break custom tool registration. UnlayerStore applies
+             * the grouped config via setMergeTags once the editor is ready.
+             */
             mergeTags: toUnlayerMergeTags(mergeTags, { groups: false }),
             projectId: 5713,
             version: latest ? undefined : versions.unlayer,
@@ -362,8 +366,6 @@ export const createUnlayerEditor = (
         document.getElementById = currentFind;
     }
 
-    scheduleUnlayerMergeTags(result, mergeTags);
-
     if (displayConditions) {
         result.registerCallback(
             'displayCondition',