@formicoidea/labre-core 0.33.0 → 0.34.1

package/dist/_pkgs/affine-model/elements/estuarine/estuarine.js

@@ -32,8 +32,9 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
+import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, polygonNearestPoint, } from '../../../global/gfx/index.js';
 import { field, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { backgroundIncludesPoint } from '../framework-background/index.js';
 /**
  * A static "Estuarine framework" map: the 2D energy (e, vertical, double-headed)
  * / time (t, horizontal) space with the three reference curves — Liminal (green),
@@ -101,9 +102,13 @@ let EstuarineElementModel = (() => {
         getNearestPoint(point) {
             return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
         }
-        includesPoint(x, y) {
-            const points = getPointsFromBoundWithRotation(this);
-            return pointInPolygon([x, y], points);
+        /**
+         * Picked by its BORDER band — see {@link backgroundIncludesPoint}. The map is
+         * a space constraint nodes are dropped into, so the clicks inside it are
+         * theirs.
+         */
+        includesPoint(x, y, options) {
+            return backgroundIncludesPoint(this, x, y, options);
         }
         #resizeEnabled_accessor_storage = __runInitializers(this, _resizeEnabled_initializers, true);
         get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }

package/dist/_pkgs/affine-model/elements/framework-background/background.d.ts

@@ -1,6 +1,6 @@
 import type { IVec } from '../../../global/gfx/index.js';
 import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps } from '../../../std/gfx/index.js';
+import type { BaseElementProps, PointTestOptions } from '../../../std/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
 /**
  * The props every framework background carries, whatever it draws.
@@ -38,5 +38,10 @@ export declare abstract class FrameworkBackgroundElementModel<Props extends Base
     containsBound(bounds: Bound): boolean;
     getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
     getNearestPoint(point: IVec): IVec;
-    includesPoint(x: number, y: number): boolean;
+    /**
+     * Picked by its BORDER band, not by its whole area — see
+     * {@link backgroundIncludesPoint} for the why and for what a caller asking
+     * about the visible extent (`ignoreTransparent: false`) still gets.
+     */
+    includesPoint(x: number, y: number, options?: PointTestOptions): boolean;
 }

package/dist/_pkgs/affine-model/elements/framework-background/background.js

@@ -1,5 +1,6 @@
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
+import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, polygonNearestPoint, } from '../../../global/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { backgroundIncludesPoint } from './hit-test.js';
 /**
  * The MODEL half of the framework-background primitive (PF2.1).
  *
@@ -35,8 +36,12 @@ export class FrameworkBackgroundElementModel extends GfxPrimitiveElementModel {
     getNearestPoint(point) {
         return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
     }
-    includesPoint(x, y) {
-        const points = getPointsFromBoundWithRotation(this);
-        return pointInPolygon([x, y], points);
+    /**
+     * Picked by its BORDER band, not by its whole area — see
+     * {@link backgroundIncludesPoint} for the why and for what a caller asking
+     * about the visible extent (`ignoreTransparent: false`) still gets.
+     */
+    includesPoint(x, y, options) {
+        return backgroundIncludesPoint(this, x, y, options);
     }
 }

package/dist/_pkgs/affine-model/elements/framework-background/hit-test.d.ts

@@ -0,0 +1,48 @@
+import type { IBound } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+/**
+ * The width of the band a background is picked by, in SCREEN pixels.
+ *
+ * Ten is what every caller on the picking path already asks for
+ * (`getElementByPoint`, the default tool, the gfx view event handler all pass
+ * `hitThreshold: 10`); naming it here gives the one caller that passes nothing
+ * — the frame manager, which calls `includesPoint(x, y, {})` — the same band
+ * instead of a shape's 1-pixel default.
+ */
+export declare const BACKGROUND_BORDER_HIT_THRESHOLD = 10;
+/**
+ * Whether a point picks a framework background — THE hit test every background
+ * in the library shares.
+ *
+ * ## A background is picked by its border, not by its area
+ *
+ * A background is a passive canvas: the user drops nodes onto it and works on
+ * THEM. A hit test over the whole rectangle makes the backdrop compete with its
+ * own content for every click — it wins outright when it sits above in the
+ * paint order (`getElementByPoint` keeps the topmost hit), and it fills every
+ * gap when it sits below (the interior of an unfilled shape, the space beside a
+ * small node). Both were reported from the same recette (issue #194).
+ *
+ * So the band IS the affordance: within `hitThreshold` screen pixels of the
+ * (rotated) outline, and nowhere else. The threshold is divided by the zoom for
+ * the reason every shape divides it — a border band has to stay the same width
+ * under the pointer whatever the viewport is doing.
+ *
+ * ## The interior still answers "is the pointer on this element"
+ *
+ * `ignoreTransparent: false` is the existing way a caller says it is asking
+ * about the element's visible EXTENT rather than about what a click would pick
+ * — an unfilled shape answers the same two ways for the same reason
+ * (`rect.includesPoint`). Exactly two callers pass it: the default tool, which
+ * uses it to decide whether a press on an ALREADY-SELECTED element starts a
+ * move, and the connector manager, which never sees a background at all
+ * (`connectable` is false). So a selected background keeps being dragged from
+ * anywhere inside it, and only picking changed.
+ *
+ * ## What did NOT change
+ *
+ * `containsBound` / `intersectsBound` (the lasso), `getNearestPoint` and
+ * `getLineIntersections` are untouched: a rubber band that had to graze the
+ * outline would be a second regression dressed as a fix.
+ */
+export declare function backgroundIncludesPoint(bounds: IBound, x: number, y: number, options?: PointTestOptions): boolean;

package/dist/_pkgs/affine-model/elements/framework-background/hit-test.js

@@ -0,0 +1,55 @@
+import { getPointsFromBoundWithRotation, pointInPolygon, pointOnPolygonStoke, } from '../../../global/gfx/index.js';
+/**
+ * The width of the band a background is picked by, in SCREEN pixels.
+ *
+ * Ten is what every caller on the picking path already asks for
+ * (`getElementByPoint`, the default tool, the gfx view event handler all pass
+ * `hitThreshold: 10`); naming it here gives the one caller that passes nothing
+ * — the frame manager, which calls `includesPoint(x, y, {})` — the same band
+ * instead of a shape's 1-pixel default.
+ */
+export const BACKGROUND_BORDER_HIT_THRESHOLD = 10;
+/**
+ * Whether a point picks a framework background — THE hit test every background
+ * in the library shares.
+ *
+ * ## A background is picked by its border, not by its area
+ *
+ * A background is a passive canvas: the user drops nodes onto it and works on
+ * THEM. A hit test over the whole rectangle makes the backdrop compete with its
+ * own content for every click — it wins outright when it sits above in the
+ * paint order (`getElementByPoint` keeps the topmost hit), and it fills every
+ * gap when it sits below (the interior of an unfilled shape, the space beside a
+ * small node). Both were reported from the same recette (issue #194).
+ *
+ * So the band IS the affordance: within `hitThreshold` screen pixels of the
+ * (rotated) outline, and nowhere else. The threshold is divided by the zoom for
+ * the reason every shape divides it — a border band has to stay the same width
+ * under the pointer whatever the viewport is doing.
+ *
+ * ## The interior still answers "is the pointer on this element"
+ *
+ * `ignoreTransparent: false` is the existing way a caller says it is asking
+ * about the element's visible EXTENT rather than about what a click would pick
+ * — an unfilled shape answers the same two ways for the same reason
+ * (`rect.includesPoint`). Exactly two callers pass it: the default tool, which
+ * uses it to decide whether a press on an ALREADY-SELECTED element starts a
+ * move, and the connector manager, which never sees a background at all
+ * (`connectable` is false). So a selected background keeps being dragged from
+ * anywhere inside it, and only picking changed.
+ *
+ * ## What did NOT change
+ *
+ * `containsBound` / `intersectsBound` (the lasso), `getNearestPoint` and
+ * `getLineIntersections` are untouched: a rubber band that had to graze the
+ * outline would be a second regression dressed as a fix.
+ */
+export function backgroundIncludesPoint(bounds, x, y, options) {
+    const point = [x, y];
+    const points = getPointsFromBoundWithRotation(bounds);
+    const threshold = (options?.hitThreshold ?? BACKGROUND_BORDER_HIT_THRESHOLD) /
+        (options?.zoom ?? 1);
+    if (pointOnPolygonStoke(point, points, threshold))
+        return true;
+    return options?.ignoreTransparent === false && pointInPolygon(point, points);
+}

package/dist/_pkgs/affine-model/elements/framework-background/index.d.ts

@@ -1 +1,2 @@
 export * from './background.js';
+export * from './hit-test.js';

package/dist/_pkgs/affine-model/elements/framework-background/index.js

@@ -1 +1,2 @@
 export * from './background.js';
+export * from './hit-test.js';

package/dist/_pkgs/affine-shared/services/edit-props-store.d.ts

@@ -405,6 +405,17 @@ export declare class EditPropsStore extends LifeCycleWatcher {
     dispose(): void;
     getStorage<T extends StoragePropsKey>(key: T): StorageProps[T] | null;
     recordLastProps(key: LastPropsKey, props: Partial<LastProps[LastPropsKey]>): void;
+    /**
+     * Remember the edgeless viewport of the current editing session, so the next
+     * mount of this doc reopens where the user left it.
+     *
+     * The storage key is shared by every mount of the same doc, so a read-only
+     * mount — an embedded preview, a mini map — must not overwrite what the full
+     * editor remembered: a preview is not an editing session. Readonly is read
+     * here, at save time (the edgeless root block saves on unmount), so a
+     * session that turns read-only before unmounting stops writing too.
+     */
+    saveViewport(viewport: StorageProps['viewport']): void;
     setStorage<T extends StoragePropsKey>(key: T, value: StorageProps[T]): void;
     unmounted(): void;
 }

package/dist/_pkgs/affine-shared/services/edit-props-store.js

@@ -156,6 +156,21 @@ export class EditPropsStore extends LifeCycleWatcher {
         const nextProps = mergeWith(clonedeep(innerProps), { [key]: overrideProps }, customizer);
         this.innerProps$.value = OptionalPropsSchema.parse(nextProps);
     }
+    /**
+     * Remember the edgeless viewport of the current editing session, so the next
+     * mount of this doc reopens where the user left it.
+     *
+     * The storage key is shared by every mount of the same doc, so a read-only
+     * mount — an embedded preview, a mini map — must not overwrite what the full
+     * editor remembered: a preview is not an editing session. Readonly is read
+     * here, at save time (the edgeless root block saves on unmount), so a
+     * session that turns read-only before unmounting stops writing too.
+     */
+    saveViewport(viewport) {
+        if (this.std.store.readonly)
+            return;
+        this.setStorage('viewport', viewport);
+    }
     setStorage(key, value) {
         const oldValue = this.getStorage(key);
         this._getStorage(key).setItem(this._getStorageKey(key), JSON.stringify(value));

package/dist/_pkgs/affine-shared/services/toolbar-service/action.d.ts

@@ -1,4 +1,6 @@
+import type { BlockStdScope } from '../../../std/index.js';
 import type { TemplateResult } from 'lit';
+import { type ChromeWording } from '../translation-service/index.js';
 import type { ToolbarContext } from './context.js';
 export declare enum ActionPlacement {
     Start = 0,
@@ -25,9 +27,28 @@ type ActionBase = {
 };
 export type ToolbarAction = ActionBase & {
     label?: string;
+    /**
+     * The same word as {@link label}, said as an i18n key with its English
+     * default — resolved against the host's catalogue when the row is built, and
+     * written over `label` there (`combine`, in the toolbar widget).
+     *
+     * It exists because `label` is a VALUE and the translation seam needs `std`:
+     * a literal here is the one wording a host cannot override, which is what
+     * left a fully translated editor saying "Duplicate" and "Card view" in
+     * English (#183). Declaring the pair keeps a call site one line — the shape a
+     * static label already had — instead of pushing every entry that has words
+     * into a `generate`.
+     *
+     * Wordings are declared once in `@labre/affine-shared/services`
+     * (`CHROME_WORDINGS`), which is also what the key manifest walks — a pair
+     * spelt inline at a call site would be a key no host is ever offered.
+     */
+    labelWording?: ChromeWording;
     showLabel?: boolean;
     icon?: TemplateResult;
     tooltip?: string | TemplateResult;
+    /** {@link labelWording}, for the tooltip. Written over `tooltip`. */
+    tooltipWording?: ChromeWording;
     variant?: 'destructive';
     disabled?: ((cx: ToolbarContext) => boolean) | boolean;
     content?: ((cx: ToolbarContext) => TemplateResult | null) | (TemplateResult | null);
@@ -45,4 +66,15 @@ export type ToolbarActionGroupGenerator = ActionBase & {
 };
 export type ToolbarGenericAction = ToolbarAction | ToolbarActionGenerator | ToolbarActionGroup | ToolbarActionGroupGenerator;
 export type ToolbarActions<T extends ActionBase = ToolbarGenericAction> = T[];
+/**
+ * What an entry SAYS, whether it declared a wording or a literal label.
+ *
+ * The row itself never needs this — `combine` resolves `labelWording` onto
+ * `label` before anything is drawn. It exists for the entries a widget renders
+ * ITSELF out of the raw declarations, which is exactly what the view switcher
+ * does: `content(ctx)` hands its own children to `affine-view-dropdown-menu`,
+ * so those never pass through `combine` and would otherwise be the one control
+ * in the editor left saying "Card view" in English (#183).
+ */
+export declare function toolbarActionLabel(std: BlockStdScope, action: ToolbarAction): string;
 export {};

package/dist/_pkgs/affine-shared/services/toolbar-service/action.js

@@ -1,3 +1,4 @@
+import { translateKey } from '../translation-service/index.js';
 export var ActionPlacement;
 (function (ActionPlacement) {
     ActionPlacement[ActionPlacement["Start"] = 0] = "Start";
@@ -5,3 +6,18 @@ export var ActionPlacement;
     ActionPlacement[ActionPlacement["End"] = 2] = "End";
     ActionPlacement[ActionPlacement["More"] = 4] = "More";
 })(ActionPlacement || (ActionPlacement = {}));
+/**
+ * What an entry SAYS, whether it declared a wording or a literal label.
+ *
+ * The row itself never needs this — `combine` resolves `labelWording` onto
+ * `label` before anything is drawn. It exists for the entries a widget renders
+ * ITSELF out of the raw declarations, which is exactly what the view switcher
+ * does: `content(ctx)` hands its own children to `affine-view-dropdown-menu`,
+ * so those never pass through `combine` and would otherwise be the one control
+ * in the editor left saying "Card view" in English (#183).
+ */
+export function toolbarActionLabel(std, action) {
+    return action.labelWording
+        ? translateKey(std, ...action.labelWording)
+        : (action.label ?? '');
+}

package/dist/_pkgs/affine-shared/services/toolbar-service/flags.d.ts

@@ -9,11 +9,21 @@ export declare enum Flag {
     Accepting = 64
 }
 export declare class Flags {
+    #private;
     value$: import("@preact/signals-core").Signal<Flag>;
+    get revision(): number;
+    get revision$(): import("@preact/signals-core").Signal<number>;
     get value(): Flag;
     toggle(flag: Flag, activated: boolean): void;
     check(flag: Flag, value?: Flag): boolean;
     contains(flag: number, value?: Flag): boolean;
+    /**
+     * Forces subscribers to re-run while keeping `flag` activated.
+     *
+     * The revision bump is what actually notifies; the batch keeps both writes
+     * in a single notification so the toolbar never sees a transient
+     * {@link Flag.None} frame.
+     */
     refresh(flag: Flag): void;
     reset(): void;
     hide(): void;

package/dist/_pkgs/affine-shared/services/toolbar-service/flags.js

@@ -16,6 +16,30 @@ export var Flag;
 export class Flags {
     constructor() {
         this.value$ = signal(Flag.None);
+        /**
+         * Bumped on every {@link Flags.refresh} call.
+         *
+         * `refresh` intentionally leaves `value$` unchanged, so it cannot be used as
+         * a repaint channel on its own: since `@preact/signals-core` 1.14 a `batch`
+         * that ends on its initial value notifies nobody. Subscribers that must
+         * re-run on a forced refresh have to read this revision counter as well.
+         */
+        this.#revision$ = signal(0);
+    }
+    /**
+     * Bumped on every {@link Flags.refresh} call.
+     *
+     * `refresh` intentionally leaves `value$` unchanged, so it cannot be used as
+     * a repaint channel on its own: since `@preact/signals-core` 1.14 a `batch`
+     * that ends on its initial value notifies nobody. Subscribers that must
+     * re-run on a forced refresh have to read this revision counter as well.
+     */
+    #revision$;
+    get revision() {
+        return this.#revision$.peek();
+    }
+    get revision$() {
+        return this.#revision$;
     }
     get value() {
         return this.value$.peek();
@@ -33,10 +57,17 @@ export class Flags {
     contains(flag, value = this.value) {
         return (flag & value) !== Flag.None;
     }
+    /**
+     * Forces subscribers to re-run while keeping `flag` activated.
+     *
+     * The revision bump is what actually notifies; the batch keeps both writes
+     * in a single notification so the toolbar never sees a transient
+     * {@link Flag.None} frame.
+     */
     refresh(flag) {
         batch(() => {
-            this.toggle(flag, false);
             this.toggle(flag, true);
+            this.#revision$.value++;
         });
     }
     reset() {

package/dist/_pkgs/affine-shared/services/translation-service/chrome.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The editor's own chrome wordings, as `[key, fallback]` pairs.
+ *
+ * ## Why they are a table and not forty literals
+ *
+ * "Copy", "Delete", "Card view" are the SAME word on a dozen toolbars — the
+ * bookmark's, the image's, the embed's, the linked doc's — and a literal per
+ * call site is a wording a host has to translate a dozen times and can get
+ * twelve different answers for. One pair per word, imported where it is
+ * rendered, is what makes the manifest's promise ("every key the library can
+ * ask for") describe a list a human can actually word.
+ *
+ * ## The tuple shape is load-bearing
+ *
+ * `translateKey(std, ...COPY)` spreads into `(std, key, fallback)`, so a call
+ * site names the wording once and cannot pair the wrong fallback with the right
+ * key. It is also what
+ * `packages/affine/all/src/__tests__/translations/manifest.unit.spec.ts` reads:
+ * the two adjacent literals below are the pair its drift check confirms the
+ * manifest against, which is why the wordings live in literals here rather than
+ * being derived from anything.
+ *
+ * Chrome, so every one of them ships an English default: a standalone
+ * playground with no `TranslationProvider` registered must read exactly as it
+ * did before these keys existed.
+ */
+/** A wording the library can ask the host for: its key, and its English default. */
+export type ChromeWording = readonly [key: string, fallback: string];
+/**
+ * The transient messages the editor puts on screen after a gesture.
+ *
+ * They were the last English strings left in a fully translated host (#182):
+ * silent while nobody injected a `NotificationProvider`, and English in the
+ * middle of a French UI the moment somebody did.
+ */
+export declare const TOAST_COPIED_TO_CLIPBOARD: ChromeWording;
+export declare const TOAST_LINKED_DOC_CREATED: ChromeWording;
+export declare const TOAST_NOTE_REMOVED_FROM_PAGE: ChromeWording;
+export declare const TOAST_FRAME_INSERTED_INTO_PAGE: ChromeWording;
+export declare const TOAST_NO_LINK_FOUND: ChromeWording;
+export declare const TOOLBAR_BRING_TO_FRONT: ChromeWording;
+export declare const TOOLBAR_SEND_TO_BACK: ChromeWording;
+export declare const TOOLBAR_COPY: ChromeWording;
+export declare const TOOLBAR_DUPLICATE: ChromeWording;
+export declare const TOOLBAR_DELETE: ChromeWording;
+export declare const TOOLBAR_LOCK: ChromeWording;
+export declare const TOOLBAR_MORE: ChromeWording;
+export declare const TOOLBAR_LINK: ChromeWording;
+export declare const TOOLBAR_CREATE_LINKED_DOC: ChromeWording;
+export declare const TOOLBAR_DRAW_CONNECTOR: ChromeWording;
+/**
+ * The four wordings of the view switcher — the control that decides whether a
+ * link is drawn as words, as a card or as the document itself.
+ *
+ * One set for every block that offers it (bookmark, attachment, embed, linked
+ * doc, synced doc, iframe, the inline link and the inline reference): they are
+ * one control with one vocabulary, and a host that had to word "Card view"
+ * eight times would end up with eight wordings of it.
+ */
+export declare const TOOLBAR_SWITCH_VIEW: ChromeWording;
+export declare const TOOLBAR_INLINE_VIEW: ChromeWording;
+export declare const TOOLBAR_CARD_VIEW: ChromeWording;
+export declare const TOOLBAR_EMBED_VIEW: ChromeWording;
+/**
+ * The four states a linked-doc card can be in with nothing to show: deleted,
+ * unreadable, empty, and — for the SYNCED card, which frames a page rather
+ * than a doc — empty in its own words.
+ *
+ * All four and not only the two the recette caught (#183): they are one
+ * sentence rendered by one ternary, and translating half of it would leave a
+ * card that changes language when the document it points at goes missing.
+ */
+export declare const LINKED_DOC_DELETED: ChromeWording;
+export declare const LINKED_DOC_FAILED: ChromeWording;
+export declare const LINKED_DOC_EMPTY_PREVIEW: ChromeWording;
+export declare const SYNCED_DOC_EMPTY_PREVIEW: ChromeWording;
+/**
+ * The resize toggle, which is the one entry EVERY framework board carries —
+ * Wardley, BPMN, C4, EDGY, Cynefin, Estuarine and the two DDD boards all
+ * register the same always-on button (`docs/adr/0009`: a stored board must stay
+ * usable with its framework switched off).
+ *
+ * Declared here rather than once per framework because it is not a framework's
+ * own word: it names a behaviour of the generic frame primitive, and eight
+ * copies of it in eight manifests would be eight keys for one tooltip.
+ */
+export declare const BOARD_RESIZE_TOGGLE: ChromeWording;
+/**
+ * The legend button, in the two wordings the boards actually use: the notation
+ * boards say "notation", Wardley says "components".
+ *
+ * Two keys and not one interpolated sentence, for the reason the interchange
+ * counts already ran on — the seam has no interpolation, so the smallest honest
+ * unit is the whole sentence.
+ */
+export declare const BOARD_LEGEND_NOTATION: ChromeWording;
+export declare const BOARD_LEGEND_COMPONENTS: ChromeWording;
+/**
+ * Every wording declared above, in declaration order.
+ *
+ * The manifest (`@labre/affine/translations`) walks this instead of restating
+ * the pairs, so a wording added here reaches a host's catalogue with no second
+ * edit — the same "declared data, not restated data" rule the roles, the rules
+ * and the commands already follow.
+ */
+export declare const CHROME_WORDINGS: readonly ChromeWording[];