efficient-easel 0.0.0 → 0.97.0

package/dist/strings/catalogue.d.ts

@@ -0,0 +1,141 @@
+import { S as SaveWords } from '../words-CsRWXkY4.js';
+import { N as NoticeWords, C as ChromeWords } from '../words-DagJdwIA.js';
+import { C as CopyWords } from '../words-DfxEp_RH.js';
+import { D as DragWords } from '../words-D9ChvbNC.js';
+import { LockWords } from '../edit-lock/index.js';
+import { F as FieldsWords } from '../words-CD3WADyb.js';
+import { N as NodeMenuWords } from '../words-DOhF-4D4.js';
+import { S as SettingsBucket } from '../buckets-1vRlQceY.js';
+import { P as PickWords } from '../words-B87GIFWH.js';
+import { S as StyleClipboardWords } from '../words-B2YLaKEr.js';
+import { T as TreeWords } from '../words-BK-npta-.js';
+import '../types-CuNiSnX6.js';
+import '../types-DNrn_w4V.js';
+import '../wordFit-9B9nqyf3.js';
+import 'react';
+import '../markup/index.js';
+
+/**
+ * The editor canvas's own words (`efficient-easel/strings`, 0.95.0). There is
+ * one: what the frame is called when the host does not name it (`title`).
+ *
+ * A plain module with no import.
+ */
+type CanvasWords = {
+    /** The canvas frame's accessible name. */
+    frame: string;
+};
+
+/**
+ * The settings panel's own words (`efficient-easel/strings`, 0.95.0): what
+ * the tab strip is called, and what each tab SAYS.
+ *
+ * A bucket's key (`'Content'`, `'Style'`, …) is an identifier — fields name
+ * their tab with it and `SETTINGS_BUCKETS` orders them — so it never changes
+ * with the language. `buckets` is the word drawn for each key.
+ *
+ * The panel is hook-free, so nothing here is read from the strings provider:
+ * `SettingsTabs` takes its name as `ariaLabel` and each tab's word as the
+ * item's `label`, and `Inspector` (which has hooks) passes both.
+ */
+
+type PanelWords = {
+    /** The tab strip's accessible name. */
+    settings: string;
+    /** The word each tab shows, by its key. */
+    buckets: Record<SettingsBucket, string>;
+};
+
+/**
+ * The rail's own words. There is one: what the toolbar is called when the host
+ * does not name it (`ariaLabel`). Every other word on the rail is an item's
+ * `label`, and those are the host's.
+ *
+ * A plain module with no import, so the rail stays the leaf it is
+ * (`tests/rail-leaf-safety.test.tsx`). It is NOT exported from `./index`: the
+ * rail's runtime exports are pinned (`tests/rail-public-shape.test.tsx`), and a
+ * host reads these through `efficient-easel/strings`.
+ */
+type RailWords = {
+    /** The toolbar's accessible name. */
+    label: string;
+};
+
+/**
+ * THE ENGINE'S OWN WORDS, as one catalogue a host can translate (0.95.0).
+ *
+ * Every word and sentence this package itself draws or returns — visible text,
+ * `aria-label`s, tooltips, placeholders — is an entry here, grouped by the
+ * module that says it. What a HOST supplies (a block's name, a field's label, a
+ * tile's caption, the document's noun) was never the engine's and is not here.
+ *
+ *   - A plain word is a `string`.
+ *   - Anything with a value in it, or a count that can be one or many, is a
+ *     function: the host puts the value where its language wants it and does
+ *     its own plural.
+ *
+ * ── Where the English lives ───────────────────────────────────────────────
+ * In each module's own `words.ts`, NOT here. A leaf may only import its own
+ * lane (`tests/*-leaf-safety`), and several are held to a bundle that never
+ * spells a browser global — while one sentence below does ("another tab or
+ * window"). So a module owns its group and its defaults, and this file only
+ * puts the groups side by side. `DEFAULT_EDITOR_STRINGS.pick` IS the pickers'
+ * own default object, not a copy of it.
+ *
+ * ── Framework-free ────────────────────────────────────────────────────────
+ * No React, no browser global, nothing run at import but object literals
+ * (`tests/strings-leaf-safety.test.ts`). A server-side test in a host imports
+ * this to check its own catalogues against the engine's keys; it is published
+ * on its own as `efficient-easel/strings/catalogue`. The provider and the
+ * hooks are in ./provider.
+ */
+
+/** Every word the engine says, by the module that says it. */
+interface EditorStrings {
+    /** `efficient-easel/chrome` — `EditNotice`: who holds the document, a refused save. */
+    notice: NoticeWords;
+    /** `efficient-easel/edit-lock` — "2 minutes ago", "Someone else". */
+    lock: LockWords;
+    /** `efficient-easel/autosave` — the save pill. */
+    save: SaveWords;
+    /** `efficient-easel/chrome` — the device switch, "up one level", the panel grip. */
+    chrome: ChromeWords;
+    /** `efficient-easel/rail` — the toolbar's name. */
+    rail: RailWords;
+    /** `efficient-easel/tree` — the drag hint and the caret. */
+    tree: TreeWords;
+    /** `efficient-easel/panel` — the tab strip's name and each tab's word. */
+    panel: PanelWords;
+    /** `efficient-easel/fields` — the number box, the dropdown, the list field. */
+    fields: FieldsWords;
+    /** `efficient-easel/pick` — the colour row and the image box. */
+    pick: PickWords;
+    /** `efficient-easel/drag` — the Add panel and the canvas layer. */
+    drag: DragWords;
+    /** `efficient-easel/node-ops` — the right-click rows. */
+    menu: NodeMenuWords;
+    /** `efficient-easel/style-clipboard` — Copy style, Paste style and what a paste says. */
+    styleClipboard: StyleClipboardWords;
+    /** `efficient-easel/copy` — the formatting bar, alignment, the link window, each mark. */
+    copy: CopyWords;
+    /** `efficient-easel/editor` — the canvas frame's name. */
+    canvas: CanvasWords;
+}
+/** Today's English, word for word. */
+declare const DEFAULT_EDITOR_STRINGS: EditorStrings;
+/**
+ * A catalogue with any part left out. A function entry is taken whole or not
+ * at all: it has no "part" to leave out.
+ */
+type DeepPartial<T> = T extends (...args: never[]) => unknown ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * `defaults` with every entry `partial` gives laid over it. Whatever `partial`
+ * leaves out (or gives as `undefined` / `null`) keeps the default, so a host
+ * that has translated half the catalogue shows the other half in English
+ * rather than as nothing. Neither argument is changed.
+ */
+declare function mergeEditorStrings(defaults: EditorStrings, partial?: DeepPartial<EditorStrings> | null): EditorStrings;
+
+export { type CanvasWords, ChromeWords, CopyWords, DEFAULT_EDITOR_STRINGS, type DeepPartial, DragWords, type EditorStrings, FieldsWords, LockWords, NodeMenuWords, NoticeWords, type PanelWords, PickWords, type RailWords, SaveWords, StyleClipboardWords, TreeWords, mergeEditorStrings };

package/dist/strings/catalogue.js

@@ -0,0 +1 @@
+export{DEFAULT_EDITOR_STRINGS,mergeEditorStrings}from"../chunk-OGZFDJ6G.js";import"../chunk-ZAOM6PFH.js";import"../chunk-6WY6ZXJG.js";import"../chunk-GGTPNGFJ.js";import"../chunk-SUO5627P.js";import"../chunk-H4B72XCJ.js";import"../chunk-7A7O2JWQ.js";import"../chunk-WK3AFPXY.js";import"../chunk-H6DDIBQ4.js";import"../chunk-KDIVA6WD.js";import"../chunk-RE4LP46F.js";import"../chunk-2OAZYSWJ.js";import"../chunk-2LUSK32B.js";import"../chunk-6OPSJGAI.js";import"../chunk-O2NLQBFX.js";

package/dist/strings/index.d.ts

@@ -0,0 +1,56 @@
+import { DeepPartial, EditorStrings } from './catalogue.js';
+export { CanvasWords, DEFAULT_EDITOR_STRINGS, PanelWords, RailWords, mergeEditorStrings } from './catalogue.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+export { C as ChromeWords, N as NoticeWords } from '../words-DagJdwIA.js';
+export { C as CopyWords } from '../words-DfxEp_RH.js';
+export { D as DragWords } from '../words-D9ChvbNC.js';
+export { F as FieldsWords } from '../words-CD3WADyb.js';
+export { LockWords } from '../edit-lock/index.js';
+export { N as NodeMenuWords } from '../words-DOhF-4D4.js';
+export { P as PickWords } from '../words-B87GIFWH.js';
+export { S as SaveWords } from '../words-CsRWXkY4.js';
+export { S as StyleClipboardWords } from '../words-B2YLaKEr.js';
+export { T as TreeWords } from '../words-BK-npta-.js';
+import '../buckets-1vRlQceY.js';
+import '../markup/index.js';
+import '../types-CuNiSnX6.js';
+import '../types-DNrn_w4V.js';
+import '../wordFit-9B9nqyf3.js';
+
+interface EditorStringsProviderProps {
+    /**
+     * The host's words, laid over the ones in reach — the engine's English, or an
+     * outer provider's. Anything left out keeps what was there.
+     *
+     * Pass an object that keeps its identity between renders (a module constant,
+     * a `useMemo`): a new object every render is a new catalogue every render,
+     * and everything that reads it draws again.
+     */
+    value?: DeepPartial<EditorStrings>;
+    /**
+     * The language those words are in, as a BCP 47 tag (`'de'`, `'zh-Hant'`). The
+     * engine does not read it; `useEditorLocale()` hands it to a host's blocks and
+     * fields, so a number or a date drawn in the editor follows the same language.
+     * Left out: an outer provider's, else `'en'`.
+     */
+    locale?: string;
+    children?: ReactNode;
+}
+/**
+ * Puts a host's words in reach of every engine component under it that reads
+ * them. With no provider the engine speaks English, exactly as before 0.95.0.
+ *
+ * The hook-free leaves do NOT read it — the rail, the settings-panel
+ * primitives, the Layers tree, the pickers, the Add panel, the canvas layer —
+ * and neither do the plain functions (`editNotice`, `saveIndicator`,
+ * `nodeMenuItems`, …). Each takes its group as a prop or an argument instead;
+ * a host hands it `useEditorStrings()`'s.
+ */
+declare function EditorStringsProvider({ value, locale, children }: EditorStringsProviderProps): react.JSX.Element;
+/** The whole catalogue: the nearest provider's, or the engine's English. */
+declare function useEditorStrings(): EditorStrings;
+/** The nearest provider's locale, or `'en'`. */
+declare function useEditorLocale(): string;
+
+export { DeepPartial, EditorStrings, EditorStringsProvider, type EditorStringsProviderProps, useEditorLocale, useEditorStrings };

package/dist/strings/index.js

@@ -0,0 +1,2 @@
+import{DEFAULT_EDITOR_STRINGS as r,mergeEditorStrings as n}from"../chunk-OGZFDJ6G.js";export{DEFAULT_EDITOR_STRINGS,mergeEditorStrings}from"../chunk-OGZFDJ6G.js";import"../chunk-ZAOM6PFH.js";import"../chunk-6WY6ZXJG.js";import"../chunk-GGTPNGFJ.js";import"../chunk-SUO5627P.js";import"../chunk-H4B72XCJ.js";import"../chunk-7A7O2JWQ.js";import"../chunk-WK3AFPXY.js";import"../chunk-H6DDIBQ4.js";import"../chunk-KDIVA6WD.js";import"../chunk-RE4LP46F.js";import"../chunk-2OAZYSWJ.js";import"../chunk-2LUSK32B.js";import"../chunk-6OPSJGAI.js";import{stringsContext as o}from"../chunk-MFIRYGHW.js";import"../chunk-O2NLQBFX.js";import{useContext as t,useMemo as i}from"react";import{jsx as c}from"react/jsx-runtime";function s({value:s,locale:u,children:m}){const e=o(),p=t(e),h=p?.strings??r,j=u??p?.locale??"en",k=i(()=>({strings:n(h,s),locale:j}),[h,s,j]);/* @__PURE__ */
+return c(e.Provider,{value:k,children:m})}function u(){return t(o())?.strings??r}function m(){return t(o())?.locale??"en"}export{s as EditorStringsProvider,m as useEditorLocale,u as useEditorStrings};

package/dist/style-clipboard/index.d.ts

@@ -0,0 +1,184 @@
+import { E as EditorContextMenuItem } from '../types-pGBXevBU.js';
+import { S as StyleClipboardWords } from '../words-B2YLaKEr.js';
+import 'react';
+
+/**
+ * `efficient-easel/style-clipboard` — COPY STYLE and PASTE STYLE, for both editors.
+ *
+ * Owner, 2026-09-19 (card [ADD] Copy Style And Paste Style): copy a component's
+ * look, paste it onto another component, in the campaign designer AND the
+ * website editor, written once. His three answers are the three rules here:
+ *
+ *   1. ONE copy. Everything that is the same in both editors lives in this file:
+ *      the held style, the matching rule, the menu rows, the words a merchant
+ *      reads after a paste, and the shortcut test. A host only says which of its
+ *      rows are Style or Layout, and saves the new props through the one op it
+ *      already has — so a paste is one undo step, and the shell dispatches
+ *      nothing.
+ *   2. Paste onto ANY component, but only the settings the target also has. A
+ *      setting is the same setting when the KEY and the KIND are the same — see
+ *      {@link planPaste}. When we cannot tell, it is skipped.
+ *   3. Style and Layout, never Content. Which rows those are is the host's
+ *      answer (its tabs are its own); this file never sees a Content row.
+ *
+ * WHAT IS HELD. One style at a time, tagged with the SCOPE it came from (a site,
+ * a campaign). In another scope nothing is held, so a look never crosses from
+ * one site to another or from the email editor to the website editor. It is
+ * kept in memory and in `sessionStorage`, so it lasts for the editor session
+ * and survives a page load inside the same tab. Storage can be missing or throw
+ * (a private window, blocked site data); every touch is in a try/catch and the
+ * memory copy still works.
+ *
+ * A LEAF. Nothing here runs at import: no `window`, no `document`, no storage.
+ * It imports React only for the two menu glyphs, and nothing outside `src/`
+ * (`tests/style-clipboard-leaf-safety.test.ts`).
+ */
+
+/** Where a value is stored on a node's props: `['size']`, or `['mobile', 'size']`
+ *  for the campaign editor's phone value of `size`. */
+type StylePath = readonly string[];
+/** One settings row, as the host sees it. */
+interface StyleRow {
+    path: StylePath;
+    /**
+     * WHAT KIND of setting this is — the second half of "the same setting".
+     * `null` means the host cannot say, and such a row only matches on a
+     * component of the SAME type (where the same key is certainly the same
+     * field). Use {@link fieldKind} for a Puck field.
+     */
+    kind: string | null;
+    /**
+     * Counted in "Pasted N settings"? Default true. A row that only travels with
+     * another one — the campaign editor's phone value of a setting — passes
+     * false, so the number is the rows a merchant sees in the panel.
+     */
+    counted?: boolean;
+}
+/** The property a field factory sets to say what kind of setting it builds. */
+declare const STYLE_KIND: "__styleKind";
+/**
+ * Tag a field with its kind. Put it on a FACTORY (a colour picker, an
+ * alignment control), so every row the factory builds shares one kind — that
+ * is what lets Text `color` paste onto Divider `color`. Returns the same
+ * object, so a factory can `return withStyleKind({...}, 'color')`.
+ */
+declare function withStyleKind<F extends object>(field: F, kind: string): F;
+/**
+ * The kind of a Puck field.
+ *
+ *  - a tagged field → its tag;
+ *  - `text` / `textarea` / `number` → that word;
+ *  - `select` / `radio` → the word plus its sorted option values, so two
+ *    selects with different options are two different settings;
+ *  - anything else (an untagged `custom`, an `object`, an `array`, a `slot`) →
+ *    `null`: we cannot say, so it matches only on the same component type.
+ */
+/**
+ * A CHOICE row's kind: the control's word, then the values it offers, sorted —
+ * `choice:center|left|right`. Both hosts build their own choice rows with this,
+ * so one spelling reaches {@link planPaste}'s value rule below.
+ */
+declare function choiceKind(control: string, values: readonly unknown[]): string;
+declare function fieldKind(field: unknown): string | null;
+type Props = Record<string, unknown>;
+/** A copied look. */
+interface StyleSnapshot {
+    scope: string;
+    /** The source's component type — for the same-type rule of a `null` kind. */
+    sourceType: string;
+    /** The source's name, as the menu and the message say it: "Heading". */
+    sourceLabel: string;
+    rows: {
+        path: string[];
+        kind: string | null;
+        counted: boolean;
+        value: unknown;
+    }[];
+}
+/**
+ * Copy a node's look. `rows` are its Style and Layout rows (the host's answer);
+ * `props` are its stored props. Every row is held, set or empty — an empty row
+ * is what makes the target inherit too.
+ */
+declare function copyStyle(input: {
+    scope: string;
+    type: string;
+    label: string;
+    rows: readonly StyleRow[];
+    props: Props;
+}): StyleSnapshot;
+/** The held look, or null when nothing is held IN THIS SCOPE. */
+declare function heldStyle(scope: string): StyleSnapshot | null;
+/** Hear about a new copy, so an open menu can redraw. Returns the unsubscribe. */
+declare function subscribeStyle(listener: () => void): () => void;
+/** Forget what is held. For tests, and for a host that must drop it. */
+declare function clearStyle(): void;
+interface PastePlan {
+    /** The target's new props. Hand them to the host's one replace op. */
+    props: Props;
+    /** How many counted rows matched — the number the merchant is told. */
+    pasted: number;
+    /** Did anything actually change? A host may skip a save that changes nothing. */
+    changed: boolean;
+}
+/**
+ * THE MATCHING RULE — the only copy of it.
+ *
+ * A held row is pasted onto a target row only when:
+ *   1. the PATH is the same (same key), and
+ *   2. the KIND is the same — or both rows are CHOICE rows of the same control
+ *      and the target offers the value being pasted (see {@link matches}), and
+ *   3. that kind is known — or the two components are the same type, where the
+ *      same key is certainly the same field.
+ *
+ * The target's rows are the rows its panel DRAWS right now, so a row the target
+ * has culled is not pasted either. An empty held value CLEARS the target row, so
+ * the target inherits exactly as the source did; nothing inherited is ever
+ * frozen into a value.
+ */
+declare function planPaste(snapshot: StyleSnapshot, target: {
+    type: string;
+    rows: readonly StyleRow[];
+    props: Props;
+}): PastePlan;
+/** The words a merchant reads after a paste. One copy, so both editors say the
+ *  same thing — including, plainly, when nothing matched. `words` is the host's
+ *  language (`useEditorStrings().styleClipboard`, 0.95.0); left out, English. */
+declare function pasteMessage(plan: Pick<PastePlan, 'pasted'>, sourceLabel: string, targetLabel: string, words?: StyleClipboardWords): string;
+/** The two shortcuts, as a menu draws them. */
+declare const COPY_STYLE_SHORTCUT = "\u2325\u2318C";
+declare const PASTE_STYLE_SHORTCUT = "\u2325\u2318V";
+/**
+ * The menu rows, in order: Copy style, then Paste style.
+ *
+ * A row that would do nothing is not drawn — both menus' written rule. So
+ * `Copy style` is left out when the node has no Style or Layout row
+ * (`canCopy: false`), and `Paste style` until something is held in this scope.
+ * The paste row names what it will paste: "Paste style from Heading".
+ */
+declare function styleMenuItems(opts: {
+    held: StyleSnapshot | null;
+    canCopy: boolean;
+    onCopy: () => void;
+    onPaste: () => void;
+    /** The rows' words in the host's language (`useEditorStrings().styleClipboard`, 0.95.0). Left out, English. */
+    words?: StyleClipboardWords;
+}): EditorContextMenuItem[];
+/**
+ * Is this key press Copy style or Paste style?
+ *
+ * ⌘⌥C / ⌘⌥V on a Mac, Ctrl+Alt+C / Ctrl+Alt+V elsewhere — the keys Figma and
+ * Google Docs use. Read from `code`, not `key`: on a Mac, Option turns `c` into
+ * `ç`. A press inside something you type in is left alone: there the merchant
+ * is editing words, not choosing a component.
+ */
+declare function styleShortcut(e: {
+    code: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    target?: unknown;
+}): 'copy' | 'paste' | null;
+
+export { COPY_STYLE_SHORTCUT, PASTE_STYLE_SHORTCUT, type PastePlan, STYLE_KIND, StyleClipboardWords, type StylePath, type StyleRow, type StyleSnapshot, choiceKind, clearStyle, copyStyle, fieldKind, heldStyle, pasteMessage, planPaste, styleMenuItems, styleShortcut, subscribeStyle, withStyleKind };

package/dist/style-clipboard/index.js

@@ -0,0 +1 @@
+import{DEFAULT_STYLE_CLIPBOARD_WORDS as t}from"../chunk-6WY6ZXJG.js";import{CopyStyleIcon as e,PasteStyleIcon as n}from"../chunk-YNZZYHA4.js";import{jsx as o}from"react/jsx-runtime";var r="__styleKind";function u(t,e){return t[r]=e,t}function c(t,e){return`${t}:${e.map(t=>String(t)).sort().join("|")}`}function i(t){if(!t)return null;const e=t.indexOf(":");if(e<0)return null;const n=t.slice(0,e);return s.has(n)?{control:n,values:t.slice(e+1).split("|")}:null}var s=/* @__PURE__ */new Set(["choice","select","radio"]);function l(t){if(!t||"object"!=typeof t)return null;const e=t;return"string"==typeof e[r]?e[r]:"text"===e.type||"textarea"===e.type||"number"===e.type?e.type:"select"!==e.type&&"radio"!==e.type||!Array.isArray(e.options)?null:c(e.type,e.options.map(t=>t?.value))}function a(t){return null!=t&&""!==t}function p(t,e){let n=t;for(const t of e){if(!n||"object"!=typeof n)return;n=n[t]}return n}function f(t){return void 0===t?t:JSON.parse(JSON.stringify(t))}function d(t,e,n){const[o,...r]=e,u={...t};if(0===r.length)return void 0===n?delete u[o]:u[o]=n,u;const c=u[o],i=d(c&&"object"==typeof c?c:{},r,n);return 0===Object.keys(i).length?delete u[o]:u[o]=i,u}var y=t=>t.join("."),h="editor-shell:style-clipboard",g=null,m=!1,v=/* @__PURE__ */new Set;function S(){try{return"undefined"==typeof sessionStorage?null:sessionStorage}catch{return null}}function b(){if(!m){m=!0;try{const t=S()?.getItem(h);t&&(g=JSON.parse(t))}catch{g=null}}}function k(t){b(),g={scope:t.scope,sourceType:t.type,sourceLabel:t.label,rows:t.rows.map(e=>{const n=p(t.props,e.path);return{path:[...e.path],kind:e.kind,counted:!1!==e.counted,value:a(n)?f(n):void 0}})};try{S()?.setItem(h,JSON.stringify(g))}catch{}return v.forEach(t=>t()),g}function N(t){return b(),g&&g.scope===t?g:null}function j(t){return v.add(t),()=>{v.delete(t)}}function C(){g=null,m=!0;try{S()?.removeItem(h)}catch{}v.forEach(t=>t())}function w(t,e,n){if(t.kind===e.kind)return null!==e.kind||n;const o=i(t.kind),r=i(e.kind);return!(!o||!r||o.control!==r.control)&&(!a(t.value)||r.values.includes(String(t.value)))}function O(t,e){const n=t.sourceType===e.type,o=new Map(t.rows.map(t=>[y(t.path),t]));let r=e.props,u=0,c=!1;for(const t of e.rows){const e=o.get(y(t.path));if(!e)continue;if(!w(e,t,n))continue;const i=p(r,t.path),s=void 0===e.value?void 0:f(e.value);JSON.stringify(a(i)?i:void 0)!==JSON.stringify(s)&&(r=d(r,t.path,s),c=!0),!1!==t.counted&&(u+=1)}return{props:r,pasted:u,changed:c}}function E(e,n,o,r=t){return 0===e.pasted?r.nothing({source:n,target:o}):r.pasted({count:e.pasted,source:n})}var J="⌥⌘C",K="⌥⌘V";function T(r){const u=r.words??t,c=[];return r.canCopy&&c.push({label:u.copy,icon:/* @__PURE__ */o(e,{}),shortcut:"⌥⌘C",onClick:r.onCopy}),r.held&&c.push({label:u.paste({source:r.held.sourceLabel}),icon:/* @__PURE__ */o(n,{}),shortcut:"⌥⌘V",onClick:r.onPaste}),c}function x(t){if(!t.altKey||t.shiftKey||!t.metaKey&&!t.ctrlKey)return null;const e=t.target;return e&&(e.isContentEditable||"INPUT"===e.tagName||"TEXTAREA"===e.tagName||"SELECT"===e.tagName)?null:"KeyC"===t.code?"copy":"KeyV"===t.code?"paste":null}export{J as COPY_STYLE_SHORTCUT,K as PASTE_STYLE_SHORTCUT,r as STYLE_KIND,c as choiceKind,C as clearStyle,k as copyStyle,l as fieldKind,N as heldStyle,E as pasteMessage,O as planPaste,T as styleMenuItems,x as styleShortcut,j as subscribeStyle,u as withStyleKind};

package/dist/tree/index.d.ts

@@ -0,0 +1,173 @@
+import * as react from 'react';
+import { ReactNode, HTMLAttributes, ButtonHTMLAttributes } from 'react';
+import { T as TreeWords } from '../words-BK-npta-.js';
+
+type LayersTreeProps = {
+    /** Extra classes — a host's scroll-bar class, for instance. */
+    className?: string;
+    children?: ReactNode;
+    /** Attributes for the tree's root — `efficient-easel/drag`'s `rootProps()`. */
+    rootProps?: HTMLAttributes<HTMLDivElement>;
+};
+type TreeGroupLabelProps = {
+    children: ReactNode;
+};
+type SubtreeProps = {
+    children?: ReactNode;
+};
+type TreeRowFold = {
+    /** Whether the row's subtree is showing. */
+    open: boolean;
+    /** What folds, in lower case — "section", "column". The caret reads "Collapse section". */
+    label: string;
+    onToggle: () => void;
+};
+type TreeRowProps = {
+    /** A 13px glyph for the row's type. */
+    icon: ReactNode;
+    /** The row's name — the type's label, or a name the person gave it. */
+    name: ReactNode;
+    /**
+     * The thing's own first words, drawn quieter after the name — "Text  BACK IN
+     * STOCK NOW". NEW in 0.42.0: a tree of fifteen rows called "Section" cannot be
+     * searched by eye. The host decides the words and shortens them.
+     */
+    preview?: ReactNode;
+    selected?: boolean;
+    /** Hidden from the page: the name is struck through and the eye stays showing. */
+    hidden?: boolean;
+    /**
+     * The row can be picked up — whole, by `efficient-easel/drag` (0.74.0). It says
+     * so four ways: a faint ⋮ at its left on hover, the grab cursor, a hint after
+     * 0.7 s ("Drag to move · ⌥↑ ⌥↓"), and the row lifted with a shadow while it
+     * moves. A draggable row draws no `handle`: the row IS the handle.
+     */
+    draggable?: boolean;
+    /** The hint a draggable row shows after 0.7 s. Default `words.dragHint`: "Drag to move · ⌥↑ ⌥↓". */
+    dragHint?: string;
+    /** This row is being dragged. */
+    dragging?: boolean;
+    /** Where a drop would land relative to this row, while a drag is over it. */
+    drop?: 'before' | 'after' | 'into';
+    /** Present when the row folds; the row leads with its caret. Absent: the caret column is held open. */
+    fold?: TreeRowFold;
+    /**
+     * Props for the drag handle button (the host's drag-and-drop wiring). Absent:
+     * no handle. The handle is the ONLY drag source, so it is hidden with opacity
+     * and never made unreachable.
+     *
+     * @deprecated since 0.74.0 — a row driven by `efficient-easel/drag` is picked
+     * up whole (`draggable`), and a draggable row draws no handle. Kept until both
+     * editors have moved (blueprint 3.3 / 3.4).
+     */
+    handle?: ButtonHTMLAttributes<HTMLButtonElement>;
+    /** `TreeRowAction`s — laid over the END of the name, shown on hover and focus. */
+    actions?: ReactNode;
+    /** Stands in for the name — a rename box. It must not move the row by a pixel. */
+    nameSlot?: ReactNode;
+    /**
+     * Selects the row. Present: the name box becomes a real <button> — Enter and
+     * Space select from the keyboard — and a selected row says `aria-current`.
+     * Absent: the row selects through `rowProps.onClick`, as 0.42.0 did.
+     */
+    onSelect?: () => void;
+    /** Named state glyphs drawn right after the name — "Hidden on phones". */
+    marks?: ReadonlyArray<TreeRowMark>;
+    /** A count or position pill after the name — "1 of 2". */
+    badge?: ReactNode;
+    /** A non-interactive mark at the row's end — the Lock on a pinned section. */
+    trailing?: {
+        label: string;
+        icon: ReactNode;
+    };
+    /** Drawn inside the row after everything else: overlays such as a drop line. */
+    children?: ReactNode;
+    /** Attributes for the row itself: onClick, drag-over handlers, data-*. */
+    rowProps?: HTMLAttributes<HTMLDivElement> & Record<`data-${string}`, string | number | undefined>;
+    /**
+     * The row's own words — the drag hint and the caret's — in the host's
+     * language: `useEditorStrings().tree` (0.95.0). Left out, English. `dragHint`
+     * above still wins for its one line.
+     */
+    words?: TreeWords;
+};
+type TreeRowMark = {
+    key: string;
+    /** Tooltip and accessible name — the mark is a picture of a state. */
+    label: string;
+    icon: ReactNode;
+};
+type TreeRowActionProps = {
+    /**
+     * `delete` is the red trash; `eye` shows or hides; `plain` is any other action
+     * (a phone toggle, "Duplicate column") in the neutral colour.
+     */
+    kind: 'delete' | 'eye' | 'plain';
+    /** For a toggle: whether it is on. Adds aria-pressed and keeps it visible at rest. */
+    pressed?: boolean;
+    disabled?: boolean;
+    /** Tooltip and accessible name — "Delete Text", "Show Section". */
+    label: string;
+    onClick: () => void;
+    children: ReactNode;
+};
+type TreeSeamProps = {
+    /** A drag is over this gap and may land in it: draw the drop line. */
+    drop?: boolean;
+    /** Present: the gap offers a "+" that adds here (it opens the Add panel at this place). */
+    onAdd?: () => void;
+    /** The "+"'s accessible name and tooltip — "Add block here". Required with `onAdd`. */
+    label?: string;
+    /** The drag handlers — `efficient-easel/drag`'s `seam(…).seamProps`. */
+    seamProps?: HTMLAttributes<HTMLDivElement>;
+};
+
+/**
+ * The Layers tree's container. It declares the TREE's own rhythm — 10px above a
+ * group label, 6px between rows — under the shell's names, so the settings panel
+ * beside it keeps its own 48 / 38 (the owner picked the tree's two numbers by eye,
+ * 2026-08-31; they are not a scale of the panel's).
+ */
+declare function LayersTree({ className, children, rootProps }: LayersTreeProps): react.JSX.Element;
+/** A quiet uppercase label over a run of rows — "Header", "Body", "Footer". */
+declare function TreeGroupLabel({ children }: TreeGroupLabelProps): react.JSX.Element;
+/**
+ * The rows one level down. THE ONLY THING IN THE TREE THAT SAYS DEPTH: 16px of
+ * indent and a hairline down the left that runs the height of the group, so a
+ * child eight rows down still shows which parent it is under.
+ */
+declare function Subtree({ children }: SubtreeProps): react.JSX.Element;
+
+/** What a draggable row says after 0.7 s on it. */
+declare const TREE_DRAG_HINT: string;
+/**
+ * ONE row, at every depth (the owner's "One Ladder", 2026-09-04).
+ *
+ * Lifted from the website editor's `.sf-row` (efficient-shop). Left to right:
+ * the drag handle (out of flow, in the row's left padding), the caret — or a
+ * spacer holding its column open, so every glyph below lines up whether its row
+ * folds or not — the type glyph, then the name box. The actions are laid over
+ * the END of the name rather than holding space beside it; that choice won the
+ * name 138px → 223px of room in the website tree.
+ *
+ * Depth is said by `Subtree` and by nothing here. A row's look never changes
+ * with how deep it sits.
+ *
+ * Hook-free and controlled: selection, folding, hiding and dragging all belong
+ * to the host. So are its words: the drag hint and the caret's come in as
+ * `words` (./words), English when left out — a hook-free row reads no provider.
+ */
+declare function TreeRow({ icon, name, preview, selected, hidden, draggable, dragHint, dragging, drop, fold, handle, actions, nameSlot, onSelect, marks, badge, trailing, children, rowProps, words, }: TreeRowProps): react.JSX.Element;
+/**
+ * A 22px action over the end of a row's name — delete (red) or show / hide.
+ * Pressing it never selects the row underneath.
+ */
+declare function TreeRowAction({ kind, label, onClick, pressed, disabled, children }: TreeRowActionProps): react.JSX.Element;
+/**
+ * The gap between two rows, as a place (0.74.0): a drop between them lands here,
+ * and — when the host offers it — a "+" adds here. It takes exactly the space
+ * the gap already had, so a list reads the same with seams or without.
+ */
+declare function TreeSeam({ drop, onAdd, label, seamProps }: TreeSeamProps): react.JSX.Element;
+
+export { LayersTree, type LayersTreeProps, Subtree, type SubtreeProps, TREE_DRAG_HINT, TreeGroupLabel, type TreeGroupLabelProps, TreeRow, TreeRowAction, type TreeRowActionProps, type TreeRowFold, type TreeRowMark, type TreeRowProps, TreeSeam, type TreeSeamProps, TreeWords };

package/dist/tree/index.js

@@ -0,0 +1 @@
+export{LayersTree,Subtree,TREE_DRAG_HINT,TreeGroupLabel,TreeRow,TreeRowAction,TreeSeam}from"../chunk-STFMZJKU.js";import"../chunk-H4B72XCJ.js";import"../chunk-YNZZYHA4.js";