@formicoidea/labre-core 0.40.0 → 0.42.0

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

@@ -26,8 +26,14 @@ export interface TranslationService {
     /**
      * Resolve an i18n key. Return `undefined` when the catalogue has no entry,
      * so the caller can fall back rather than render an empty bubble.
+     *
+     * `params` carries the values of a sentence with holes in it ("Failed to
+     * upload {{name}}"). The host interpolates them — and pluralises on `count` —
+     * with its own i18n stack; the placeholders are i18next's `{{name}}`, so a
+     * catalogue seeded from the manifest's fallbacks works as is. A host that
+     * ignores `params` still type-checks and simply shows its unfilled wording.
      */
-    t(key: string): string | undefined;
+    t(key: string, params?: TranslationParams): string | undefined;
     /**
      * The language the catalogue is currently serving, as a BCP-47 tag
      * (`'fr'`, `'en-GB'`). Optional, and NOT locale negotiation — the library
@@ -51,6 +57,34 @@ export interface TranslationService {
  * framework has a convention that holds in `en-GB` and not in `en-US`.
  */
 export declare function hostLanguage(std: BlockStdScope): string | undefined;
+/**
+ * The host's full language tag (`'fr-CA'`), or `undefined` when no host said —
+ * for `Intl` formatting of dates and numbers, where the region matters
+ * (`en-GB` and `en-US` write a date differently). `undefined` hands `Intl` the
+ * runtime default, which is what the editor did before hosts could say.
+ */
+export declare function hostLocale(std: BlockStdScope): string | undefined;
+/**
+ * `hostLocale(std)`, defaulting to `'en-US'` when the host said nothing —
+ * the locale every `Intl.*Format` call in the library resolves against.
+ *
+ * Dates and numbers fall back to English like every string does, so a
+ * standalone playground stays deterministic: `Intl`'s own runtime-default
+ * fallback would instead read whatever locale the machine happens to have,
+ * which is not a fallback a test can assert on.
+ */
+export declare function formatLocale(std: BlockStdScope): string;
+/** The values of a wording's `{{name}}` placeholders. */
+export type TranslationParams = Record<string, string | number>;
+/**
+ * Fill `{{name}}` placeholders from `params`; a placeholder with no value is
+ * left as written, so a missing argument shows rather than vanishes.
+ *
+ * The library's side of interpolation only — used on the English fallback when
+ * the host has no entry. Pluralisation is the host's: a fallback stays neutral
+ * ("{{count}} element(s)").
+ */
+export declare function fillPlaceholders(wording: string, params?: TranslationParams): string;
 export declare const TranslationProvider: import("../../../global/di/types.js").ServiceIdentifier<TranslationService> & (<U extends TranslationService = TranslationService>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
 export declare const TranslationExtension: (service: TranslationService) => ExtensionType;
 /**
@@ -65,5 +99,9 @@ export declare const TranslationExtension: (service: TranslationService) => Exte
  *   made up.
  * - **Chrome** (the word "Warning" on a severity chip) passes an English
  *   default, so a standalone playground reads correctly without a catalogue.
+ *
+ * `params` fill the wording's `{{name}}` placeholders: handed to the host,
+ * which interpolates its own translation, and filled here into the fallback
+ * when the host has none.
  */
-export declare function translateKey(std: BlockStdScope, key: string, fallback?: string): string;
+export declare function translateKey(std: BlockStdScope, key: string, fallback?: string, params?: TranslationParams): string;

package/dist/_pkgs/affine-shared/services/translation-service/index.js

@@ -13,6 +13,41 @@ export function hostLanguage(std) {
         return undefined;
     return tag.split('-')[0].toLowerCase();
 }
+/**
+ * The host's full language tag (`'fr-CA'`), or `undefined` when no host said —
+ * for `Intl` formatting of dates and numbers, where the region matters
+ * (`en-GB` and `en-US` write a date differently). `undefined` hands `Intl` the
+ * runtime default, which is what the editor did before hosts could say.
+ */
+export function hostLocale(std) {
+    const tag = std.getOptional(TranslationProvider)?.language;
+    return typeof tag === 'string' && tag.length > 0 ? tag : undefined;
+}
+/**
+ * `hostLocale(std)`, defaulting to `'en-US'` when the host said nothing —
+ * the locale every `Intl.*Format` call in the library resolves against.
+ *
+ * Dates and numbers fall back to English like every string does, so a
+ * standalone playground stays deterministic: `Intl`'s own runtime-default
+ * fallback would instead read whatever locale the machine happens to have,
+ * which is not a fallback a test can assert on.
+ */
+export function formatLocale(std) {
+    return hostLocale(std) ?? 'en-US';
+}
+/**
+ * Fill `{{name}}` placeholders from `params`; a placeholder with no value is
+ * left as written, so a missing argument shows rather than vanishes.
+ *
+ * The library's side of interpolation only — used on the English fallback when
+ * the host has no entry. Pluralisation is the host's: a fallback stays neutral
+ * ("{{count}} element(s)").
+ */
+export function fillPlaceholders(wording, params) {
+    if (!params)
+        return wording;
+    return wording.replace(/\{\{\s*(\w+)\s*\}\}/g, (hole, name) => name in params ? String(params[name]) : hole);
+}
 export const TranslationProvider = createIdentifier('AffineTranslationService');
 export const TranslationExtension = (service) => {
     return {
@@ -33,8 +68,14 @@ export const TranslationExtension = (service) => {
  *   made up.
  * - **Chrome** (the word "Warning" on a severity chip) passes an English
  *   default, so a standalone playground reads correctly without a catalogue.
+ *
+ * `params` fill the wording's `{{name}}` placeholders: handed to the host,
+ * which interpolates its own translation, and filled here into the fallback
+ * when the host has none.
  */
-export function translateKey(std, key, fallback = key) {
-    const resolved = std.getOptional(TranslationProvider)?.t(key);
-    return resolved !== undefined && resolved !== '' ? resolved : fallback;
+export function translateKey(std, key, fallback = key, params) {
+    const resolved = std.getOptional(TranslationProvider)?.t(key, params);
+    return resolved !== undefined && resolved !== ''
+        ? resolved
+        : fillPlaceholders(fallback, params);
 }

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.d.ts

@@ -1,4 +1,4 @@
-import type { BlockStdScope, FrameworkId } from '../../std/index.js';
+import type { BlockStdScope, FrameworkId, TranslationKeyManifestEntry } from '../../std/index.js';
 import type { RoleDefs, RoleId } from '../../std/gfx/index.js';
 import type { ExtensionType } from '../../store/index.js';
 /**
@@ -15,9 +15,31 @@ export type TagValueId = string;
 export type TagValueDef = {
     /** `'<tagId>/<local>'`, e.g. `'wardley:nature/data'`. */
     id: TagValueId;
-    /** Display label, already localized by the host. */
+    /**
+     * Display label. For a HOST-seeded pack this is already localized — the app
+     * seeds a pack per deployment and `label` is that deployment's own wording,
+     * same as ever. For the library's OWN pack (`WARDLEY_TAG_DEFS`, the format's
+     * worked example) it is the ENGLISH fallback beside {@link labelKey}, on the
+     * same seam every other library string uses (ADR 0007 § 2bis's rule for role
+     * labels, extended here to tag values).
+     */
     label: string;
+    /**
+     * i18n key resolved by the host's catalogue, `label` its fallback — see
+     * {@link translateTagLabel}. Optional and additive: a pack seeded before this
+     * field existed (or a host pack that never sets it) still shows `label`
+     * exactly as it always has.
+     */
+    labelKey?: string;
     description?: string;
+    /**
+     * i18n key resolved by the host's catalogue, `description` its fallback —
+     * see {@link translateTagDescription}. Optional and additive, on the same
+     * seam as {@link labelKey}: a pack seeded before this field existed (or a
+     * host pack that never sets it) still shows `description` exactly as it
+     * always has.
+     */
+    descriptionKey?: string;
     /** Advisory colour token. The library may ignore it; it never affects layout. */
     color?: string;
     /** Hidden from pickers; still displayed when already present on an element. */
@@ -26,8 +48,13 @@ export type TagValueDef = {
 export type TagDef = {
     /** `'<framework>:<local>'`, e.g. `'wardley:nature'`. */
     id: QualifiedId;
+    /** See {@link TagValueDef.label}. */
     label: string;
+    /** See {@link TagValueDef.labelKey}. */
+    labelKey?: string;
     description?: string;
+    /** See {@link TagValueDef.descriptionKey}. */
+    descriptionKey?: string;
     /** How many values an element may carry for this tag. */
     cardinality: 'single' | 'multi';
     /** A closed list, or `'open'` for free-text values. */
@@ -68,8 +95,62 @@ export type UniverseTagDefs = {
     packId: string;
     framework: FrameworkId;
     label: string;
+    /**
+     * i18n key for the PACK's own `label` — see {@link TagValueDef.labelKey}
+     * for the seam. Optional and additive: a pack seeded before this field
+     * existed (or a host pack that never sets it) still shows `label` exactly
+     * as it always has.
+     */
+    labelKey?: string;
     tags: TagDef[];
 };
+/**
+ * The DISPLAYED wording of a tag def or a tag value def — {@link translateKey}
+ * over {@link TagDef.labelKey} / {@link TagValueDef.labelKey} when present,
+ * `label` unresolved otherwise (a host pack that never sets `labelKey` shows
+ * exactly what it always has).
+ *
+ * The one function every RENDERER of a tag label goes through — the "Qualify"
+ * toolbar's section titles and options (`tags-toolbar.ts`), the reading
+ * panel's nature value (`reading-widget.ts`). `resolveRecordNature` in
+ * `reading.ts` deliberately does NOT: it matches an external record's words
+ * against `label`, which is a comparison and not a display, and the wording it
+ * matches against is the one the record itself was written with.
+ *
+ * The same shape resolves a PACK's own `label` too (`UniverseTagDefs.label` /
+ * `.labelKey`): both carry an identical `{ label, labelKey? }` pair, so no
+ * second function is needed for it.
+ */
+export declare function translateTagLabel(std: BlockStdScope, def: Pick<TagDef | TagValueDef | UniverseTagDefs, 'label' | 'labelKey'>): string;
+/**
+ * The DISPLAYED description of a tag def or a tag value def —
+ * {@link translateKey} over {@link TagDef.descriptionKey} /
+ * {@link TagValueDef.descriptionKey} when present, `description` unresolved
+ * otherwise. The mirror of {@link translateTagLabel} for the `description`
+ * field, on the same seam: a def with no `descriptionKey` (a pack seeded
+ * before the field existed, or one that never sets it) keeps showing
+ * `description` exactly as it always has — including `undefined`, when the
+ * def carries no description at all.
+ */
+export declare function translateTagDescription(std: BlockStdScope, def: Pick<TagDef | TagValueDef, 'description' | 'descriptionKey'>): string | undefined;
+/**
+ * A pack's contribution to the translation-key manifest — every `labelKey`
+ * (the pack's own, a tag's, or a tag value's) and every `descriptionKey` (a
+ * tag's or a tag value's) it declares, paired with `label` / `description`
+ * as its English fallback.
+ *
+ * Manual, not `collectTranslationKeys('tag', pack)`: that generic walker pairs
+ * a `labelKey` with a sibling `labelFallback` (the roles' / rules' own
+ * convention), and this format's fallback field is named `label` — the same
+ * field a host-seeded pack's ALREADY-localized wording lives in. Walking it
+ * generically would either miss the fallback entirely or, worse, treat a
+ * host's own pack as a manifest contribution the library never asked for.
+ *
+ * For the library's own pack ONLY (`WARDLEY_TAG_DEFS` — see
+ * `wardleyTranslationEntries`); a host's app-seeded pack needs no entry here,
+ * because it carries no key at all unless the host itself decides to add one.
+ */
+export declare function tagDefsTranslationEntries(pack: UniverseTagDefs): TranslationKeyManifestEntry[];
 /** A seed-time problem, for a host diagnostics panel. Never thrown. */
 export type UniverseDefIssue = {
     severity: 'warning' | 'error';

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.js

@@ -24,11 +24,101 @@
 import { createIdentifier } from '../../global/di/index.js';
 import { FRAMEWORK_IDS } from '../../std/index.js';
 import { roleIsA } from '../../std/gfx/index.js';
+import { translateKey } from './translation-service/index.js';
 /**
  * Lower-kebab, case-sensitive, no unicode, no dots. Hyphenated framework ids
  * are legal, so `cynefin-estuarine:domain` is well formed.
  */
 const ID_PATTERN = /^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)?$/;
+/**
+ * The DISPLAYED wording of a tag def or a tag value def — {@link translateKey}
+ * over {@link TagDef.labelKey} / {@link TagValueDef.labelKey} when present,
+ * `label` unresolved otherwise (a host pack that never sets `labelKey` shows
+ * exactly what it always has).
+ *
+ * The one function every RENDERER of a tag label goes through — the "Qualify"
+ * toolbar's section titles and options (`tags-toolbar.ts`), the reading
+ * panel's nature value (`reading-widget.ts`). `resolveRecordNature` in
+ * `reading.ts` deliberately does NOT: it matches an external record's words
+ * against `label`, which is a comparison and not a display, and the wording it
+ * matches against is the one the record itself was written with.
+ *
+ * The same shape resolves a PACK's own `label` too (`UniverseTagDefs.label` /
+ * `.labelKey`): both carry an identical `{ label, labelKey? }` pair, so no
+ * second function is needed for it.
+ */
+export function translateTagLabel(std, def) {
+    return def.labelKey ? translateKey(std, def.labelKey, def.label) : def.label;
+}
+/**
+ * The DISPLAYED description of a tag def or a tag value def —
+ * {@link translateKey} over {@link TagDef.descriptionKey} /
+ * {@link TagValueDef.descriptionKey} when present, `description` unresolved
+ * otherwise. The mirror of {@link translateTagLabel} for the `description`
+ * field, on the same seam: a def with no `descriptionKey` (a pack seeded
+ * before the field existed, or one that never sets it) keeps showing
+ * `description` exactly as it always has — including `undefined`, when the
+ * def carries no description at all.
+ */
+export function translateTagDescription(std, def) {
+    if (!def.descriptionKey)
+        return def.description;
+    return translateKey(std, def.descriptionKey, def.description ?? '');
+}
+/**
+ * A pack's contribution to the translation-key manifest — every `labelKey`
+ * (the pack's own, a tag's, or a tag value's) and every `descriptionKey` (a
+ * tag's or a tag value's) it declares, paired with `label` / `description`
+ * as its English fallback.
+ *
+ * Manual, not `collectTranslationKeys('tag', pack)`: that generic walker pairs
+ * a `labelKey` with a sibling `labelFallback` (the roles' / rules' own
+ * convention), and this format's fallback field is named `label` — the same
+ * field a host-seeded pack's ALREADY-localized wording lives in. Walking it
+ * generically would either miss the fallback entirely or, worse, treat a
+ * host's own pack as a manifest contribution the library never asked for.
+ *
+ * For the library's own pack ONLY (`WARDLEY_TAG_DEFS` — see
+ * `wardleyTranslationEntries`); a host's app-seeded pack needs no entry here,
+ * because it carries no key at all unless the host itself decides to add one.
+ */
+export function tagDefsTranslationEntries(pack) {
+    const out = [];
+    if (pack.labelKey) {
+        out.push({ key: pack.labelKey, fallback: pack.label, source: 'tag' });
+    }
+    for (const tag of pack.tags) {
+        if (tag.labelKey) {
+            out.push({ key: tag.labelKey, fallback: tag.label, source: 'tag' });
+        }
+        if (tag.descriptionKey) {
+            out.push({
+                key: tag.descriptionKey,
+                fallback: tag.description ?? '',
+                source: 'tag',
+            });
+        }
+        if (tag.values !== 'open') {
+            for (const value of tag.values) {
+                if (value.labelKey) {
+                    out.push({
+                        key: value.labelKey,
+                        fallback: value.label,
+                        source: 'tag',
+                    });
+                }
+                if (value.descriptionKey) {
+                    out.push({
+                        key: value.descriptionKey,
+                        fallback: value.description ?? '',
+                        source: 'tag',
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
 /**
  * Variant-parameterized: **one registration per pack, keyed by `packId`** —
  * the same mechanism as `SpotlightHostExtension(elementType)` and
@@ -158,6 +248,8 @@ function mergeTagDef(drafts, def, pack, issue, rank) {
     const draft = existing.def;
     if (def.label !== undefined)
         draft.label = def.label;
+    if (def.labelKey !== undefined)
+        draft.labelKey = def.labelKey;
     if (def.description !== undefined)
         draft.description = def.description;
     if (def.order !== undefined)

package/dist/_pkgs/affine-shared/styles/index.d.ts

@@ -1,4 +1,5 @@
 export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font.js';
+export { reducedMotionStyle, SPRING_DURATION_MS, SPRING_EASING, springDuration, springEasing, } from './motion.js';
 export { panelBaseColorsStyle, panelBaseStyle } from './panel.js';
 export { scrollbarStyle } from './scrollbar-style.js';
 export { affineTextStyles } from './text.js';

package/dist/_pkgs/affine-shared/styles/index.js

@@ -1,4 +1,5 @@
 export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font.js';
+export { reducedMotionStyle, SPRING_DURATION_MS, SPRING_EASING, springDuration, springEasing, } from './motion.js';
 export { panelBaseColorsStyle, panelBaseStyle } from './panel.js';
 export { scrollbarStyle } from './scrollbar-style.js';
 export { affineTextStyles } from './text.js';

package/dist/_pkgs/affine-shared/styles/motion.d.ts

@@ -0,0 +1,14 @@
+/** easeOutBack: travel, overshoot a little, settle. */
+export declare const SPRING_EASING = "cubic-bezier(0.34, 1.56, 0.64, 1)";
+/** The house tempo of the edgeless chrome, in milliseconds. */
+export declare const SPRING_DURATION_MS = 240;
+/** {@link SPRING_EASING} for a `css` template. */
+export declare const springEasing: import("lit").CSSResult;
+/** {@link SPRING_DURATION_MS} for a `css` template. */
+export declare const springDuration: import("lit").CSSResult;
+/**
+ * Every animation and transition inside `container` off when the reader asked
+ * the OS for less motion. The end state is the resting state in each case, so
+ * dropping the animation loses nothing but the travel.
+ */
+export declare const reducedMotionStyle: (container: string) => import("lit").CSSResult;

package/dist/_pkgs/affine-shared/styles/motion.js

@@ -0,0 +1,38 @@
+/**
+ * The chrome's motion tokens — the first of them, and deliberately only the
+ * values the library had already converged on by hand.
+ *
+ * The edgeless chrome has been animating at ~0.23-0.24s since upstream
+ * (`edgeless-toolbar.ts`, `create-popper.ts`, `date-picker/style.ts`, `toast`),
+ * and the fork's one overshoot curve is the senior toolbar's "pop upright"
+ * (`gfx/mindmap/src/toolbar/senior-tool.ts`): `cubic-bezier(0.34, 1.56, 0.64, 1)`,
+ * the standard easeOutBack. Nothing exported it, so the second component that
+ * wanted a springy settle would have invented a third easing. This module is
+ * where it stops being a literal.
+ *
+ * `springEasing` overshoots by design — only use it on a transform that has
+ * room to overshoot (a slide, a scale, a rotation), never on a colour or on
+ * anything whose end value must never be passed.
+ */
+import { css, unsafeCSS } from 'lit';
+/** easeOutBack: travel, overshoot a little, settle. */
+export const SPRING_EASING = 'cubic-bezier(0.34, 1.56, 0.64, 1)';
+/** The house tempo of the edgeless chrome, in milliseconds. */
+export const SPRING_DURATION_MS = 240;
+/** {@link SPRING_EASING} for a `css` template. */
+export const springEasing = unsafeCSS(SPRING_EASING);
+/** {@link SPRING_DURATION_MS} for a `css` template. */
+export const springDuration = unsafeCSS(`${SPRING_DURATION_MS}ms`);
+/**
+ * Every animation and transition inside `container` off when the reader asked
+ * the OS for less motion. The end state is the resting state in each case, so
+ * dropping the animation loses nothing but the travel.
+ */
+export const reducedMotionStyle = (container) => css `
+  @media (prefers-reduced-motion: reduce) {
+    ${unsafeCSS(container)}, ${unsafeCSS(container)} * {
+      animation: none !important;
+      transition: none !important;
+    }
+  }
+`;

package/dist/_pkgs/affine-shared/utils/event.d.ts

@@ -19,6 +19,16 @@ export declare function isMiddleButtonPressed(e: MouseEvent): boolean;
 export declare function isRightButtonPressed(e: MouseEvent): boolean;
 export declare function stopPropagation(event: Event): void;
 export declare function isControlledKeyboardEvent(e: KeyboardEvent): boolean;
+/**
+ * The editor swallows Tab, Shift-Tab and Enter so that indentation and block
+ * splitting stay under the control of the block-scoped handlers. That would
+ * however trap the focus on the native controls the editor renders (the
+ * collapse button of headings and lists, for instance), which then could
+ * neither be reached, left nor activated with the keyboard. When the event
+ * originates from such a control — and not from editable text — the native
+ * behaviour is let through.
+ */
+export declare function isNativeFocusableTarget(target: EventTarget | null): boolean;
 export declare function isNewTabTrigger(event?: MouseEvent): boolean;
 export declare function isNewViewTrigger(event?: MouseEvent): boolean;
 export declare function on<T extends HTMLElement, K extends keyof M, M = HTMLElementEventMap>(element: T, event: K, handler: (ev: M[K]) => void, options?: boolean | AddEventListenerOptions): () => void;

package/dist/_pkgs/affine-shared/utils/event.js

@@ -37,6 +37,26 @@ export function stopPropagation(event) {
 export function isControlledKeyboardEvent(e) {
     return e.ctrlKey || e.metaKey || e.altKey;
 }
+// The editor host itself carries `tabindex="0"` so that it can receive the
+// keystrokes aimed at a block selection; it is the editing surface, not a
+// control, hence the exclusion.
+const NATIVE_FOCUSABLE_SELECTOR = 'button, a[href], input, select, textarea, [tabindex]:not([tabindex="-1"]):not(editor-host)';
+/**
+ * The editor swallows Tab, Shift-Tab and Enter so that indentation and block
+ * splitting stay under the control of the block-scoped handlers. That would
+ * however trap the focus on the native controls the editor renders (the
+ * collapse button of headings and lists, for instance), which then could
+ * neither be reached, left nor activated with the keyboard. When the event
+ * originates from such a control — and not from editable text — the native
+ * behaviour is let through.
+ */
+export function isNativeFocusableTarget(target) {
+    if (!(target instanceof Element))
+        return false;
+    if (target instanceof HTMLElement && target.isContentEditable)
+        return false;
+    return !!target.closest(NATIVE_FOCUSABLE_SELECTOR);
+}
 export function isNewTabTrigger(event) {
     return event
         ? (event.ctrlKey || event.metaKey || event.button === 1) && !event.altKey

package/dist/_pkgs/affine-shared/utils/file/filesys.d.ts

@@ -52,6 +52,22 @@ export declare function openSingleFileWith(acceptType?: AcceptTypes): Promise<Fi
  */
 export declare function openSingleFileWithSpec(spec: FilePickerSpec): Promise<File | null>;
 export declare function getImageFilesFromLocal(): Promise<File[]>;
+/**
+ * A name a file system will accept, minus the extension.
+ *
+ * The sanitiser the framework exports each wrote for themselves
+ * (`wardleySafeFilename`, `c4SafeFilename`, BPMN's) — same five steps, same
+ * 120-character ceiling — lifted here for the callers that belong to no
+ * framework at all. The generic SVG export (ADR 0025) is the first of them: it
+ * writes a file for ELEVEN kinds of board, so it has no framework's fallback to
+ * borrow and takes one as a parameter instead.
+ *
+ * The three framework copies stay where they are: each is part of an
+ * interchange capability with its own format id and its own declared fallback
+ * (`map`, `board`, `process`), and rewriting them to call this one would touch
+ * three exported APIs for no behaviour change.
+ */
+export declare function safeFilename(raw: string | undefined, fallback: string): string;
 export declare function downloadBlob(blob: Blob, name: string): void;
 /**
  * Because the image block and attachment block have different props.

package/dist/_pkgs/affine-shared/utils/file/filesys.js

@@ -188,6 +188,31 @@ export async function getImageFilesFromLocal() {
     const files = await openFilesWith('Images');
     return files ?? [];
 }
+/**
+ * A name a file system will accept, minus the extension.
+ *
+ * The sanitiser the framework exports each wrote for themselves
+ * (`wardleySafeFilename`, `c4SafeFilename`, BPMN's) — same five steps, same
+ * 120-character ceiling — lifted here for the callers that belong to no
+ * framework at all. The generic SVG export (ADR 0025) is the first of them: it
+ * writes a file for ELEVEN kinds of board, so it has no framework's fallback to
+ * borrow and takes one as a parameter instead.
+ *
+ * The three framework copies stay where they are: each is part of an
+ * interchange capability with its own format id and its own declared fallback
+ * (`map`, `board`, `process`), and rewriting them to call this one would touch
+ * three exported APIs for no behaviour change.
+ */
+export function safeFilename(raw, fallback) {
+    const safe = (raw ?? '')
+        .trim()
+        .replaceAll(/[\\/:*?"<>|]/g, '-')
+        .replaceAll(/\s+/g, ' ')
+        .trim()
+        .slice(0, 120)
+        .replace(/[. ]+$/, '');
+    return safe || fallback;
+}
 export function downloadBlob(blob, name) {
     const dataURL = URL.createObjectURL(blob);
     const tmpLink = document.createElement('a');

package/dist/_pkgs/affine-shared/utils/index.d.ts

@@ -13,6 +13,7 @@ export * from './fractional-indexing.js';
 export * from './image.js';
 export * from './insert.js';
 export * from './is-abort-error.js';
+export * from './link-preview-refresh.js';
 export * from './math.js';
 export * from './model/index.js';
 export * from './popper-position.js';

package/dist/_pkgs/affine-shared/utils/index.js

@@ -13,6 +13,7 @@ export * from './fractional-indexing.js';
 export * from './image.js';
 export * from './insert.js';
 export * from './is-abort-error.js';
+export * from './link-preview-refresh.js';
 export * from './math.js';
 export * from './model/index.js';
 export * from './popper-position.js';

package/dist/_pkgs/affine-shared/utils/link-preview-refresh.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from '../../store/index.js';
+/**
+ * Whether a bookmark or embed card must refetch its link preview after a props
+ * change.
+ *
+ * `BlockModel.propsUpdated` carries the key only, so a subscriber cannot tell a
+ * local edit from an update that arrived from another peer. A readonly peer
+ * receives the change like everyone else; the author is the one who refetches
+ * and syncs the result. Without this guard every reader of the document races
+ * the author to rewrite the same title, description and image.
+ */
+export declare function shouldRefreshOnPropsUpdate(store: Store, key: string): boolean;

package/dist/_pkgs/affine-shared/utils/link-preview-refresh.js

@@ -0,0 +1,13 @@
+/**
+ * Whether a bookmark or embed card must refetch its link preview after a props
+ * change.
+ *
+ * `BlockModel.propsUpdated` carries the key only, so a subscriber cannot tell a
+ * local edit from an update that arrived from another peer. A readonly peer
+ * receives the change like everyone else; the author is the one who refetches
+ * and syncs the result. Without this guard every reader of the document races
+ * the author to rewrite the same title, description and image.
+ */
+export function shouldRefreshOnPropsUpdate(store, key) {
+    return key === 'url' && !store.readonly;
+}

package/dist/_pkgs/affine-widget-drag-handle/components/edgeless-preview/preview.d.ts

@@ -1,3 +1,4 @@
+import type { BlockStdScope } from '../../../std/index.js';
 import { LitElement } from 'lit';
 declare global {
     interface HTMLElementTagNameMap {
@@ -10,6 +11,9 @@ export declare class EdgelessDndPreviewElement extends LitElement {
     accessor elementTypes: {
         type: string;
     }[];
+    /** Set by the caller that has one (`preview-helper.ts`) — optional so this
+     * element still renders (in English) when created with none. */
+    accessor std: BlockStdScope | undefined;
     private _getPreviewIcon;
     render(): import("lit-html").TemplateResult<1>;
 }