useblocks 1.1.85-dev.9 → 1.1.102

package/CHANGELOG.md

@@ -6,6 +6,97 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ---
 
+## [1.1.101] - 2026-10-12
+
+### Added
+
+- Image editor: ready-made crop ratios (1:1, 4:5, 2:3, 4:3, 3:2, 1.91:1, 21:9) and rounded image
+  corners
+- Strikethrough text in the button settings
+- PNG images are compressed harder on upload and when saved from the image editor — a palette of up
+  to 1024 colours instead of 4096: PNG photos get 2–4× lighter, transparency is kept. Animated PNGs are
+  uploaded unchanged. Compression as a whole can still be turned off with `compressMaxSize: 0`
+- File Manager: interface in German, French, Italian and Polish
+- The editor opens faster: the startup code is lighter, the code editor and rarely used dialogs load
+  on demand, and an email from the list starts loading as soon as its row is clicked. Switching emails
+  no longer flashes an empty canvas: the next email is prepared off-screen and swapped in
+- `create()` returns the editor object right away, with readiness as the `ready` promise, so handlers
+  that fire before startup finishes can already refer to it
+- Hidden start: `init({ hidden: true })` brings the editor up in its container without the interface,
+  and a second `init()` without the flag reveals it without recreating the canvas or losing state
+- The `ownership: 'counted'` option: every `init()` or `create()` in a shared container gets its own
+  object, and the editor is destroyed once all of them have released it. `getInstance(element)`
+  returns the editor object for a container
+- `show({ reload: true })` re-reads the email on the integrator's command
+- `getEmailSnapshot()` returns the open email's fields without compiling the HTML, and `validateCode()`
+  checks the email code without the code editor open. `getCodeErrors()` is deprecated
+- Autosave: the optional `handleReadEmailAutosave` handler returns the email's latest autosave;
+  autosaves are marked with `autosave: true`, and the revision `slug` field is deprecated
+- Canvas image cache `canvasImageCache`: an image is downloaded once instead of on every email show.
+  The email code keeps the original URLs
+- The `deferEditorChrome` option (on by default): the header and the right panel are built right after
+  the first frame, so the email shows up sooner
+- The Vite and webpack bundler plugins warn when a second copy of React or ui-kit ends up in the build;
+  `sharedReact: true` hands the editor your project's React (version 19)
+- The `useblocks/ui-kit/icons` subpath: a plugin imports ui-kit icons one by one, and only the ones it
+  uses end up in the build
+
+### Fixed
+
+- Email import: images whose URLs share a file name (for example, from Unisender) no longer get mixed
+  up
+- A block made of several table rows is inserted in full
+- An image in a column takes the column's width, including when columns wrap on mobile
+- Columns: vertical alignment of floating columns reaches Outlook, and "Add column" no longer resets
+  the alignment of the others; a preset with fewer columns leaves no empty gap in a non-responsive
+  email
+- Enter and Backspace in a list no longer turn text into tags; a colour typed into the field character
+  by character reaches the email
+- Non-breaking spaces in the preheader are kept
+- AMP: replacing a carousel slide image reaches the code and the export, and editing an accordion
+  section header no longer applies to the whole accordion
+- Saving in the image editor no longer lowers the image resolution
+- A file dropped onto an image in the canvas is uploaded the same way as from the image dialog —
+  through `handleLoadImage` or File Manager — and errors are shown
+- The second page of the version history shows the "Auto" label, and restoring such a version keeps
+  the email's common styles
+- An email without a title can be duplicated, and notifications no longer say "null"
+- The "System" interface theme follows the OS after a reload too
+- The settings panel no longer crashes on the countdown style buttons on the Mobile tab or in the
+  elements panel when the user has no language set
+- On a phone, the email in preview no longer overflows the screen
+- Plugin dialogs show the OK and Cancel buttons and the close icon again when the plugin does not set
+  them itself
+- Translations: "Custom fonts", the "Text" prefix of the button text replacement field, the block
+  saved notification
+
+### Changed
+
+- Global plugins with the ESM entry: the compatibility layer is off by default. Turn it on with
+  `compatGlobals: true` in the bundler plugin or by importing `useblocks/compat-globals` before the
+  editor is created. Without it the plugin fails with `` `antd` is not available… ``
+- The shared `uuid` is removed from the runtime: a plugin that took it from the editor gets a clear
+  error. Bundle `uuid` into the plugin itself
+- A plugin built with the new `PluginDev` works only with this editor version: update the editor first,
+  then the plugins
+- The ESM build of the editor runs on its own copy of React from the package: React no longer has to
+  be in your project's dependencies, and `resolve.alias` and `dedupe` do not affect the editor. An ESM
+  plugin does not work with the UMD entry of the editor — the editor reports this in the console
+- The page and the canvas talk over `MessageChannel`: `message` listeners on the page do not see canvas
+  messages. The canvas document is recreated for every email — the sandbox script runs again, and
+  `onReady` signals that each new canvas is ready
+- The canvas image cache is on by default, and images from the page's host are shown via `blob:`. With
+  a strict CSP, add `blob:` to `img-src` or turn the cache off: `canvasImageCache: false`
+- `save()` rejects when the integrator's save handler fails or does not answer in time — previously
+  such a call looked successful
+- Edit history: `undoRedoService.getPast()` and `getFuture()` return `EditStepInfo[]`, and
+  `createSnapshot()` returns a marker that cannot be stored across page loads. The `EditStackData`,
+  `EditStackSnapshot`, `ISelection` and `ISingleModelEditStackData` types are removed
+- antd labels are translated only into the product's languages: in Chinese, Japanese, Korean, Turkish,
+  Dutch and Portuguese (Portugal) they are now in English
+
+---
+
 ## [1.1.88] - 2026-10-01
 
 ### Added

package/README.md

@@ -25,7 +25,10 @@ A plugin built for globals (a UMD script loaded by URL, a descriptor with `type:
 `resolve: 'registry'`) takes antd, the icons and the ui-kit from `window.__useblocks__.modules`. With the
 ESM entry this compatibility layer is off by default: it ships the whole of antd and the icon catalogue,
 and only hosts that actually use such plugins should pay for it. Without the layer the plugin fails with
-`` `antd` is not available: the compatibility layer for global plugins is not enabled ``.
+`` `antd` is not available: the compatibility layer for global plugins is not enabled ``, ending with
+`Requested by: <url>` of the script that read the name. `modules.UiKit` and `modules.UiKitIcons` do not
+throw without the layer: they return `undefined` and log the same reason to the console once, since
+older plugins checked them for presence.
 
 Turn the layer on in one of two ways:
 
@@ -46,7 +49,7 @@ How the merged **`ExportedApi`** interfaces, **`AppEvent`** and payload types fi
 | --- | --- |
 | **`init`** | **`content` is mandatory**. **`init(options) → Promise<Instance>`**. |
 | Module vs **instance** | The **`useblocks`** bundle exports **`init`** (plus optional named ESM APIs). **`setConfig`**, **`show`**, **`save`**, **`destroy`** belong to the **`init`** return value—not the namespace object. |
-| Same DOM repeat | Calling **`init`** again on an existing mount triggers **`reset`**. Avoid parallel **`init`** on one container. |
+| Same DOM repeat | Calling **`init`** again on the same element returns **the same object** and applies options like **`setConfig`**. A call made while the previous one is still starting supersedes it: the previous promise rejects with **`AbortError`**. **`destroy()`** through any reference destroys the editor. One object per call — **`ownership: 'counted'`**. |
 | Events | **`instance.handle*(…)`** usually returns **unsubscribe**. **`handleSubjectChanged`** / **`handlePreheaderChanged`** use bespoke signatures — see typings. |
 | Async | Handlers plus **`getAuthToken`** may be **`async`**; funnel errors via **`handleError`** or your own telemetry. |
 | Build | Without Webpack/Vite helpers you must wire **`__useblocks__`** / **`publicPath`**. Expect a heavy UI bundle (React, Monaco, etc.). |
@@ -149,11 +152,11 @@ You can take **`EMAIL_CODE`** from <a href="https://cdn.useblocks.io/plugin/new-
 
 For debugging, the dev build may support a front-end token flow — configure an auth proxy in your app if you use that path.
 
-### Editor handle: `create()`
+### The editor object right away: `create()`
 
 `init()` resolves only once the editor is ready and the email from `content` is shown. Handlers fire
 earlier — inside `init()` — so they cannot refer to the editor: your variable is not assigned yet.
-`create()` returns a **handle** right away, synchronously, with readiness as a separate promise:
+`create()` returns the **editor object** right away, synchronously, with readiness as a separate promise:
 
 ```javascript
 const editor = emailmaker.create({
@@ -161,7 +164,7 @@ const editor = emailmaker.create({
   element: '#editor',
   content: { email },
   handleEmailInit: async () => {
-    // The handle already exists — it is assigned by the time the event fires.
+    // The object already exists — it is assigned by the time the event fires.
     const compiled = await editor.compileEmail(undefined, { amp: true });
     await saveOnYourSide(compiled);
   },
@@ -169,9 +172,11 @@ const editor = emailmaker.create({
 await editor.ready;
 ```
 
-You can store the handle, subscribe to events or call `destroy()` right away.
+It is a plain object, just like the result of `init()`: every method is an own property, visible to
+`Object.keys`, spread and `Object.assign`, and any method can be replaced with your own. You can store
+the object, subscribe to events or call `destroy()` right away.
 
-The handle is bound to the editor as soon as the editor is assembled — before the email from `content`
+The object is bound to the editor as soon as the editor is assembled — before the email from `content`
 is shown — so calls made from handlers (like `compileEmail()` above) reach the editor. Once bound,
 every call goes straight to the editor. Before binding:
 
@@ -182,28 +187,17 @@ every call goes straight to the editor. Before binding:
 | `setEmailMeta`, `setBlockMeta`, `notify` | applied once ready, in order |
 | `getElement()` | the element from options if it was passed as an element; `undefined` for a selector |
 | `getCodeErrors()` | an empty list |
-| `getConfig()`, `use()`, `container`, `undoRedoService` | throw — await `ready` or use `useAsync()` |
+| `getConfig()`, `use()` | throw a clear error — await `ready` or use `useAsync()` |
+| `container`, `undoRedoService` fields | `undefined`; reading them never throws |
 | `destroy()` | cancels initialisation; `ready` rejects with `AbortError` |
 
-After `destroy()` the handle is detached: its subscriptions are removed and its methods reject like a
-destroyed editor's. If another owner has already reused the element, destroying the previous handle
-leaves the editor alone and only takes its own subscriptions with it.
-
 Between binding and `ready` the email may not be shown yet. If you need the shown document — a
 `getEmailSnapshot()`, for example — await `ready` first.
 
-Another `create()` or `init()` into the same element reuses its editor with the new options (waiting for
-a start still in progress): both calls succeed and the editor belongs to the latest
-one. From then on the earlier handle is not the owner: it stops receiving events, and its `destroy()` only
-detaches it and leaves the editor alone. `destroy()` of the latest handle destroys the editor, even before
-its `ready`.
-
-If the new call passes the same data as the earlier one — the same email, configuration, user and the same
-set of handlers, even as new functions, as on every component re-render — the editor does not re-apply the
-options: the email is not shown again, `handleSetOptions` and `handleOptionsChanged` do not fire, and
-events go to the new call's handlers.
+A repeated `create()` or `init()` into the same element is described below, in
+[“Repeated init() into the same element”](#repeated-init-into-the-same-element).
 
-An initialisation error arrives as a `ready` rejection. If you create a handle and never await
+An initialisation error arrives as a `ready` rejection. If you create an object and never await
 `ready`, such an error surfaces in the console as unhandled — on purpose, otherwise there is no way to
 learn the editor did not start. The exception is `destroy()` before `ready`: that rejection is
 expected and stays quiet.
@@ -251,7 +245,7 @@ When you need full control over the lifecycle, mount the editor by hand with **`
 
 Configuration is a nested object: editor chrome, initial email payload, and callback hooks.
 
-Calling **`init`** again on the **same DOM host** reuses the editor (**`reset`**) with the new options; a start still in progress is awaited. Both calls succeed, the latest call owns the editor.
+Calling **`init`** again on the **same DOM host** returns the same object and applies the new options — see [“Repeated init() into the same element”](#repeated-init-into-the-same-element).
 
 ### Element
 
@@ -288,31 +282,70 @@ is our job, not yours.
 | metadata and document state | yes |
 | the email markup | replaced by whatever you pass in `content` |
 
-### Tear-down with more than one owner
+### Repeated init() into the same element
 
-One container outlives several owners: a page starts the editor, the next page enters the same
-container and gets the same instance. This happens without you arranging it — React unmounts the
-previous page **after** mounting the new one, and StrictMode invokes the effect twice.
+How a repeated `init()` or `create()` into the same container behaves is set by the `ownership` option.
 
-So `destroy()` tears the editor down only for the latest owner. An earlier owner's tear-down means
-"I no longer hold it" and leaves the running instance alone:
+**By default (`ownership: 'single'`) — as in 1.1.89.** The container has one editor object:
 
 ```javascript
 const first = await emailmaker.init({ element: '#editor', content });
-const second = await emailmaker.init({ element: '#editor', content });  // the same editor
+const second = await emailmaker.init({ element: '#editor', content, config });
+first === second; // true
 
-first.destroy();   // destroys nothing: second owns it now
-second.destroy();  // destroys it
+second.destroy(); // destroys the editor — through any reference
 ```
 
-Keep what the **latest** `init()` returned. Previously a late tear-down killed the editor under the
-new page, and the next show failed with `DestroyedInstanceError`.
+- A repeated call applies its options like `setConfig`. Handlers from options are swapped at once:
+  later events go to the new call's handlers. Subscriptions made through the object
+  (`editor.handleSaveEmail(cb)`) stay — it is the same object.
+- The email is shown again only if it differs from the one you set last yourself — via `init`, `show`
+  or `reset`. `init(A)` → `show(B)` → `init(A)` brings email A back. `init(A)` → `init(A)` does not
+  redraw it, so the user's edits stay.
+- If the call passes the same data as the previous one — the same email, configuration, user and the
+  same set of handlers, even as new functions, as on every component re-render — the options are not
+  re-applied: `handleSetOptions` and `handleOptionsChanged` do not fire and the token is not requested
+  again.
+- A call made while the previous one is still starting supersedes it: the previous promise rejects with
+  an `AbortError` (`emailmaker.isSupersededInitError(error)`), and only the new one succeeds.
+- `destroy()` through any reference destroys the editor, and `handleDestroy` subscribed through the
+  object fires.
+
+**`ownership: 'counted'` — an object per call.** Use it when several parts of your app share the
+editor in one container: a page starts it, the next page enters the same container, and the previous
+page's tear-down comes later — React unmounts the previous page **after** mounting the new one, and
+StrictMode invokes the effect twice.
+
+```javascript
+const first = emailmaker.create({ element: '#editor', content, ownership: 'counted' });
+const second = emailmaker.create({ element: '#editor', content, ownership: 'counted' });
+await Promise.all([first.ready, second.ready]); // both succeed, one editor
+
+first.destroy();  // releases only first's share and its subscriptions
+second.destroy(); // the last share: the editor is destroyed shortly after
+```
+
+- Every call gets its own object with all methods of the shared editor and holds a share in it. The
+  object's subscriptions live until its `destroy()`.
+- `destroy()` releases the object's share. The editor is destroyed once no shares are left — after a
+  short delay, so a tear-down immediately followed by a new call (StrictMode) does not recreate it.
+- The options and handlers of the latest call apply. When its share is released, the handlers from
+  options move to the latest remaining owner; the email and settings stay as they are.
+- `emailmaker.getInstance(element)` returns the latest call's object.
+
+**Modes can be mixed.** A call without the flag holds the editor until its object's `destroy()` and
+gets the container's shared object. Counted shares live on top of it. `destroy()` of the object without
+the flag destroys the editor with all shares — their objects then behave as after `destroy()`. In
+development mode mixing is flagged with a console warning.
+
+**If a repeated call fails to start** (the token or `app_init` failed, or it was cancelled via
+`signal`), only that call is rejected: the editor keeps its previous options and its email, restored
+from a snapshot (text and header; undo history is cleared). If the hand-back fails too, the editor is
+destroyed, and the earlier objects' methods throw `EditorStartFailedError` with the reason in `cause` —
+start the editor again with a new `init()`. Aborting the earlier call's `signal` after a new call came
+in leaves the editor alone.
 
-If the new `init()` fails to start (it failed or was cancelled via `signal`), the editor is handed back
-to the earlier owner: with its own options and its email restored from a snapshot (text and header;
-undo history is cleared). If the hand-back fails too, the editor is destroyed, and the earlier
-instance's methods throw `EditorStartFailedError` with the reason in `cause` — start the editor again
-with a new `init()`.
+`init()` into a **different** container starts a new editor.
 
 ### Content
 
@@ -626,7 +659,7 @@ See typings (**`ExportedApi.DataMixin.Events`**) — includes for example **`han
 | handleDestroy             | Destroy lifecycle                    |
 | handleLoad                | Instance ready hook                  |
 | handleLoadImage           | Image upload helpers & proxies       |
-| handleNotify              | Generic notification. Among errors: `TEMPLATE_READ_ERROR` (`data: { templateId }`) — the template named by `templateId` could not be read and the email opened without it. Sent once per template for the editor's lifetime; the event has no title and the editor shows no toast for it — show your own if the user should know. |
+| handleNotify              | Generic notification. Among warnings (`type: 'warning'`): `TEMPLATE_READ_ERROR` (`data: { templateId }`) — the template named by `templateId` could not be read and the email opened without it. Sent once per template for the editor's lifetime and never to `handleError`; the event has no title and the editor shows no toast for it — show your own if the user should know. |
 | handleError               | Error toast hook                     |
 | handleSuccess             | Success toast hook                   |
 | handleTestEmailSend       | Send test mail                       |