@formicoidea/labre-core 0.28.0 → 0.29.0

package/dist/_pkgs/affine-shared/services/linked-doc-content-service.d.ts

@@ -0,0 +1,42 @@
+import type { BlockStdScope } from '../../std/index.js';
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * Host seam for hydrating a linked doc's content on demand. An app that does not
+ * preload its whole corpus into the workspace (so a referenced doc has no
+ * content in memory) implements this to fetch/load that doc when its
+ * preview/embed needs it.
+ */
+export interface LinkedDocContentResolver {
+    /**
+     * Load the referenced doc's content into the workspace. May resolve before
+     * the content actually arrives — the preview also watches for the doc's root
+     * and is bounded by {@link LinkedDocContentResolver.timeoutMs}.
+     */
+    resolve: (docId: string) => void | Promise<void>;
+    /** Max time the preview waits for content before degrading. Default 8000ms. */
+    timeoutMs?: number;
+}
+export declare const LinkedDocContentResolverIdentifier: import("../../global/di/types.js").ServiceIdentifier<LinkedDocContentResolver> & (<U extends LinkedDocContentResolver = LinkedDocContentResolver>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/** Inject a host {@link LinkedDocContentResolver}. */
+export declare function LinkedDocContentResolverExtension(resolver: LinkedDocContentResolver): ExtensionType;
+export declare const DEFAULT_LINKED_DOC_CONTENT_TIMEOUT_MS = 8000;
+/** Minimal shape of a loadable doc store the preview waits on. */
+interface AwaitableDoc {
+    root: object | null;
+    slots: {
+        rootAdded: {
+            subscribe: (cb: () => void) => {
+                unsubscribe: () => void;
+            };
+        };
+    };
+}
+/**
+ * Resolve a linked doc's content for preview, **bounded in time**. If a host
+ * {@link LinkedDocContentResolver} is registered it is asked to hydrate the doc
+ * first. Returns `true` once the doc has a root (content available), or `false`
+ * if it timed out — in which case the caller should render a degraded preview
+ * (title only) instead of spinning forever.
+ */
+export declare function whenLinkedDocContentReady(std: BlockStdScope, doc: AwaitableDoc, docId: string): Promise<boolean>;
+export {};

package/dist/_pkgs/affine-shared/services/linked-doc-content-service.js

@@ -0,0 +1,47 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const LinkedDocContentResolverIdentifier = createIdentifier('AffineLinkedDocContentResolver');
+/** Inject a host {@link LinkedDocContentResolver}. */
+export function LinkedDocContentResolverExtension(resolver) {
+    return {
+        setup: di => {
+            di.override(LinkedDocContentResolverIdentifier, () => resolver);
+        },
+    };
+}
+export const DEFAULT_LINKED_DOC_CONTENT_TIMEOUT_MS = 8000;
+/**
+ * Resolve a linked doc's content for preview, **bounded in time**. If a host
+ * {@link LinkedDocContentResolver} is registered it is asked to hydrate the doc
+ * first. Returns `true` once the doc has a root (content available), or `false`
+ * if it timed out — in which case the caller should render a degraded preview
+ * (title only) instead of spinning forever.
+ */
+export async function whenLinkedDocContentReady(std, doc, docId) {
+    if (doc.root)
+        return true;
+    const resolver = std.getOptional(LinkedDocContentResolverIdentifier);
+    if (resolver) {
+        try {
+            await resolver.resolve(docId);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        if (doc.root)
+            return true;
+    }
+    const timeoutMs = resolver?.timeoutMs ?? DEFAULT_LINKED_DOC_CONTENT_TIMEOUT_MS;
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (ready) => {
+            if (settled)
+                return;
+            settled = true;
+            subscription.unsubscribe();
+            clearTimeout(timer);
+            resolve(ready);
+        };
+        const subscription = doc.slots.rootAdded.subscribe(() => finish(true));
+        const timer = setTimeout(() => finish(false), timeoutMs);
+    });
+}

package/dist/_pkgs/std/extension/index.d.ts

@@ -6,5 +6,6 @@ export * from './flavour.js';
 export * from './keymap.js';
 export * from './lifecycle-watcher.js';
 export * from './service.js';
+export * from './shortcut.js';
 export * from './service-manager.js';
 export * from './widget-view-map.js';

package/dist/_pkgs/std/extension/index.js

@@ -6,5 +6,6 @@ export * from './flavour.js';
 export * from './keymap.js';
 export * from './lifecycle-watcher.js';
 export * from './service.js';
+export * from './shortcut.js';
 export * from './service-manager.js';
 export * from './widget-view-map.js';

package/dist/_pkgs/std/extension/shortcut.d.ts

@@ -0,0 +1,69 @@
+import type { ExtensionType } from '../../store/index.js';
+import type { UIEventHandler } from '../event/index.js';
+import type { BlockStdScope } from '../scope/index.js';
+export type ShortcutScope = 'global' | 'page' | 'edgeless';
+/**
+ * An enumerable, rebindable keyboard shortcut. A descriptor is both a manifest
+ * entry (for a host "Shortcuts" settings panel) and the source of the actual
+ * binding. The `handler` is a factory receiving the std scope (mirroring
+ * {@link KeymapExtension}); the manifest the host consumes only needs the
+ * metadata fields, not the handler.
+ */
+export interface ShortcutDescriptor {
+    /** Stable id, e.g. `'undo'`, `'wardley.addNode'`. */
+    id: string;
+    /** i18n key; the label is resolved by the host. */
+    labelKey: string;
+    /** Default key combos per platform, each as an array, e.g. `['Mod', 'z']`. */
+    defaultKeys: {
+        mac: string[];
+        other: string[];
+    };
+    scope: ShortcutScope;
+    /** `'core'` or the owning optional-block flag, for per-framework filtering. */
+    owner: string;
+    /** Optional activation context (host-interpreted). */
+    when?: string;
+    handler: (std: BlockStdScope) => UIEventHandler;
+}
+/** Host-provided rebinding table: combo array per id, or `'disabled'`. */
+export type ShortcutOverrides = Record<string, string[] | 'disabled'>;
+export interface ShortcutConflict {
+    /** Canonical combo that more than one shortcut resolved to. */
+    combo: string;
+    scope: ShortcutScope;
+    /** Ids competing for the combo (first is the one actually bound). */
+    ids: string[];
+}
+export type ShortcutConflictReporter = (conflicts: ShortcutConflict[]) => void;
+/**
+ * Register shortcut descriptors. Each becomes a manifest entry and, once the
+ * installer ({@link ShortcutKeymapExtension}) runs, an effective binding.
+ */
+export declare function ShortcutExtension(descriptors: ShortcutDescriptor[]): ExtensionType;
+/**
+ * Canonicalize a combo (array of keys) so equivalent spellings compare equal:
+ * modifiers are lowercased/sorted and `Mod` resolves to the platform modifier;
+ * the final key is lowercased (Shift is a separate modifier).
+ */
+export declare function canonicalCombo(keys: string[]): string;
+/**
+ * Build the effective keymap for one scope from the registered descriptors and
+ * the override table. `'disabled'` ids are dropped; combo conflicts within the
+ * scope are reported (and only the first descriptor for a combo is bound — the
+ * duplicates are never bound silently).
+ */
+export declare function resolveKeymap(descriptors: ShortcutDescriptor[], overrides: ShortcutOverrides, scope: ShortcutScope, std: BlockStdScope): {
+    keymap: Record<string, UIEventHandler>;
+    conflicts: ShortcutConflict[];
+};
+/**
+ * Install the effective keymap for a scope. Reads every registered
+ * {@link ShortcutDescriptor} plus the host override table, resolves conflicts,
+ * and binds via the normal dispatcher keymap mechanism. Re-runs whenever the
+ * specs are rebuilt (e.g. a framework is toggled on/off).
+ *
+ * Only `'global'` scope is wired today; `'page'`/`'edgeless'` scoping is a
+ * follow-up.
+ */
+export declare function ShortcutKeymapExtension(scope?: ShortcutScope): ExtensionType;

package/dist/_pkgs/std/extension/shortcut.js

@@ -0,0 +1,106 @@
+import { IS_MAC } from '../../global/env/index.js';
+import { ShortcutConflictReporterIdentifier, ShortcutIdentifier, ShortcutOverrideIdentifier, } from '../identifier.js';
+import { KeymapExtension } from './keymap.js';
+let _shortcutId = 1;
+/**
+ * Register shortcut descriptors. Each becomes a manifest entry and, once the
+ * installer ({@link ShortcutKeymapExtension}) runs, an effective binding.
+ */
+export function ShortcutExtension(descriptors) {
+    return {
+        setup: di => {
+            descriptors.forEach(descriptor => {
+                di.addImpl(ShortcutIdentifier(`Shortcut-${_shortcutId++}`), descriptor);
+            });
+        },
+    };
+}
+const platformKeys = (d) => IS_MAC ? d.defaultKeys.mac : d.defaultKeys.other;
+/**
+ * Canonicalize a combo (array of keys) so equivalent spellings compare equal:
+ * modifiers are lowercased/sorted and `Mod` resolves to the platform modifier;
+ * the final key is lowercased (Shift is a separate modifier).
+ */
+export function canonicalCombo(keys) {
+    const key = (keys.at(-1) ?? '').toLowerCase();
+    const mods = keys
+        .slice(0, -1)
+        .map(m => {
+        const l = m.toLowerCase();
+        if (l === 'mod')
+            return IS_MAC ? 'meta' : 'ctrl';
+        if (l === 'cmd' || l === 'm' || l === 'meta')
+            return 'meta';
+        if (l === 'control' || l === 'c' || l === 'ctrl')
+            return 'ctrl';
+        if (l === 'a' || l === 'alt')
+            return 'alt';
+        if (l === 's' || l === 'shift')
+            return 'shift';
+        return l;
+    })
+        .sort();
+    return [...mods, key].join('-');
+}
+/**
+ * Build the effective keymap for one scope from the registered descriptors and
+ * the override table. `'disabled'` ids are dropped; combo conflicts within the
+ * scope are reported (and only the first descriptor for a combo is bound — the
+ * duplicates are never bound silently).
+ */
+export function resolveKeymap(descriptors, overrides, scope, std) {
+    const keymap = {};
+    const conflicts = [];
+    const boundBy = new Map(); // canonical combo -> bound id
+    for (const d of descriptors) {
+        if (d.scope !== scope)
+            continue;
+        const override = overrides[d.id];
+        if (override === 'disabled')
+            continue;
+        const keys = override ?? platformKeys(d);
+        if (!keys.length)
+            continue;
+        const canonical = canonicalCombo(keys);
+        const existing = boundBy.get(canonical);
+        if (existing) {
+            const conflict = conflicts.find(c => c.combo === canonical);
+            if (conflict) {
+                if (!conflict.ids.includes(d.id))
+                    conflict.ids.push(d.id);
+            }
+            else {
+                conflicts.push({ combo: canonical, scope, ids: [existing, d.id] });
+            }
+            continue; // do not silently bind a second action to the same combo
+        }
+        boundBy.set(canonical, d.id);
+        keymap[keys.join('-')] = d.handler(std);
+    }
+    return { keymap, conflicts };
+}
+/**
+ * Install the effective keymap for a scope. Reads every registered
+ * {@link ShortcutDescriptor} plus the host override table, resolves conflicts,
+ * and binds via the normal dispatcher keymap mechanism. Re-runs whenever the
+ * specs are rebuilt (e.g. a framework is toggled on/off).
+ *
+ * Only `'global'` scope is wired today; `'page'`/`'edgeless'` scoping is a
+ * follow-up.
+ */
+export function ShortcutKeymapExtension(scope = 'global') {
+    // No flavour/blockId option → a global keymap (like `fallbackKeymap`).
+    return KeymapExtension(std => {
+        const descriptors = [...std.provider.getAll(ShortcutIdentifier).values()];
+        const overrides = std.getOptional(ShortcutOverrideIdentifier) ?? {};
+        const { keymap, conflicts } = resolveKeymap(descriptors, overrides, scope, std);
+        if (conflicts.length) {
+            const report = std.getOptional(ShortcutConflictReporterIdentifier);
+            if (report)
+                report(conflicts);
+            else
+                console.warn('[shortcut] combo conflicts (duplicates not bound):', conflicts);
+        }
+        return keymap;
+    });
+}

package/dist/_pkgs/std/identifier.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from './command/index.js';
 import type { EventOptions, UIEventHandler } from './event/index.js';
 import type { BlockService, LifeCycleWatcher } from './extension/index.js';
+import type { ShortcutConflictReporter, ShortcutDescriptor, ShortcutOverrides } from './extension/shortcut.js';
 import type { BlockStdScope } from './scope/index.js';
 import type { BlockViewType } from './spec/type.js';
 export declare const BlockServiceIdentifier: import("../global/di/types.js").ServiceIdentifier<BlockService> & (<U extends BlockService = BlockService>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
@@ -27,3 +28,9 @@ export declare const KeymapIdentifier: import("../global/di/types.js").ServiceId
     getter: (std: BlockStdScope) => Record<string, UIEventHandler>;
     options?: EventOptions;
 }>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+/** Multi-instance: one registered {@link ShortcutDescriptor} per impl. */
+export declare const ShortcutIdentifier: import("../global/di/types.js").ServiceIdentifier<ShortcutDescriptor> & (<U extends ShortcutDescriptor = ShortcutDescriptor>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+/** Host-injected rebinding table (see `KeymapOverrideExtension`). */
+export declare const ShortcutOverrideIdentifier: import("../global/di/types.js").ServiceIdentifier<ShortcutOverrides> & (<U extends ShortcutOverrides = ShortcutOverrides>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);
+/** Host-injected sink for reported combo conflicts. */
+export declare const ShortcutConflictReporterIdentifier: import("../global/di/types.js").ServiceIdentifier<ShortcutConflictReporter> & (<U extends ShortcutConflictReporter = ShortcutConflictReporter>(variant: import("../global/di/types.js").ServiceVariant) => import("../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/std/identifier.js

@@ -8,3 +8,9 @@ export const WidgetViewIdentifier = createIdentifier('WidgetView');
 export const LifeCycleWatcherIdentifier = createIdentifier('LifeCycleWatcher');
 export const StdIdentifier = createIdentifier('Std');
 export const KeymapIdentifier = createIdentifier('Keymap');
+/** Multi-instance: one registered {@link ShortcutDescriptor} per impl. */
+export const ShortcutIdentifier = createIdentifier('Shortcut');
+/** Host-injected rebinding table (see `KeymapOverrideExtension`). */
+export const ShortcutOverrideIdentifier = createIdentifier('ShortcutOverride');
+/** Host-injected sink for reported combo conflicts. */
+export const ShortcutConflictReporterIdentifier = createIdentifier('ShortcutConflictReporter');

package/dist/extensions/view.js

@@ -27,7 +27,7 @@ import { BrushViewExtension } from '../_pkgs/affine-gfx-brush/view.js';
 import { ConnectorViewExtension } from '../_pkgs/affine-gfx-connector/view.js';
 import { GroupViewExtension } from '../_pkgs/affine-gfx-group/view.js';
 import { LinkViewExtension as GfxLinkViewExtension } from '../_pkgs/affine-gfx-link/view.js';
-import { MindmapRenderViewExtension, MindmapToolViewExtension, OtherToolViewExtension, } from '../_pkgs/affine-gfx-mindmap/view.js';
+import { MediaToolViewExtension, MindmapRenderViewExtension, MindmapToolViewExtension, TextToolViewExtension, } from '../_pkgs/affine-gfx-mindmap/view.js';
 import { NoteViewExtension as GfxNoteViewExtension } from '../_pkgs/affine-gfx-note/view.js';
 import { PointerViewExtension } from '../_pkgs/affine-gfx-pointer/view.js';
 import { ShapeViewExtension } from '../_pkgs/affine-gfx-shape/view.js';
@@ -69,11 +69,14 @@ export function getInternalViewExtensions(flags) {
         PointerViewExtension,
         GfxNoteViewExtension,
         ...(on('brush') ? [BrushViewExtension] : []),
+        // Standalone text / add-file senior buttons, placed right after pen/eraser
+        // (registration order = senior-row order for the default order group).
+        ...(on('edgeless-text') ? [TextToolViewExtension] : []),
+        ...(on('edgeless-media') ? [MediaToolViewExtension] : []),
         ShapeViewExtension,
         // Mindmap rendering is always on; the flags gate only the senior buttons.
         MindmapRenderViewExtension,
         ...(on('mindmap') ? [MindmapToolViewExtension] : []),
-        ...(on('other') ? [OtherToolViewExtension] : []),
         ConnectorViewExtension,
         GroupViewExtension,
         TextViewExtension,

package/dist/flags.d.ts

@@ -23,7 +23,7 @@
  * - `latex` controls both the latex block and inline latex.
  * - `frame` also controls the frame panel fragment.
  */
-export declare const OPTIONAL_BLOCKS: readonly ["attachment", "bookmark", "callout", "code", "data-view", "database", "divider", "edgeless-text", "embed", "embed-doc", "frame", "image", "latex", "list", "surface-ref", "table", "brush", "mindmap", "other", "template", "link"];
+export declare const OPTIONAL_BLOCKS: readonly ["attachment", "bookmark", "callout", "code", "data-view", "database", "divider", "edgeless-text", "embed", "embed-doc", "frame", "image", "latex", "list", "surface-ref", "table", "brush", "mindmap", "edgeless-text", "edgeless-media", "template", "link"];
 export type OptionalBlock = (typeof OPTIONAL_BLOCKS)[number];
 /** Map of optional block -> enabled. Missing keys default to enabled. */
 export type BlockFlags = Partial<Record<OptionalBlock, boolean>>;

package/dist/flags.js

@@ -43,7 +43,10 @@ export const OPTIONAL_BLOCKS = [
     // gfx modules
     'brush',
     'mindmap',
-    'other',
+    // Standalone text / add-file tools, promoted out of the former "Others"
+    // senior submenu (each individually toggleable).
+    'edgeless-text',
+    'edgeless-media',
     'template',
     'link',
 ];

package/dist/shortcuts.d.ts

@@ -0,0 +1,24 @@
+import type { ShortcutDescriptor } from './_pkgs/std/index.js';
+import { type BlockFlags, type OptionalBlock } from './flags.js';
+/**
+ * Manifest view of a shortcut: the metadata a host "Shortcuts" settings panel
+ * needs, without the runtime `handler`.
+ */
+export type ShortcutManifestEntry = Omit<ShortcutDescriptor, 'handler'>;
+interface FrameworkShortcutGroup {
+    owner: OptionalBlock;
+    shortcuts: ShortcutDescriptor[];
+}
+/**
+ * Pure aggregator (exported for testing): core shortcuts plus the shortcuts of
+ * every framework group whose flag is enabled.
+ */
+export declare function buildShortcutManifest(core: ShortcutDescriptor[], groups: FrameworkShortcutGroup[], flags?: BlockFlags): ShortcutManifestEntry[];
+/**
+ * The enumerable shortcut manifest for a given flag set: core shortcuts plus
+ * the shortcuts contributed by the currently-enabled frameworks. Enumerable
+ * without an editor instance (for a settings panel). Mirrors the flag gating of
+ * `getInternalViewExtensions`.
+ */
+export declare function getShortcutManifest(flags?: BlockFlags): ShortcutManifestEntry[];
+export {};

package/dist/shortcuts.js

@@ -0,0 +1,39 @@
+import { coreShortcuts } from './_pkgs/affine-block-root/index.js';
+import { isBlockEnabled } from './flags.js';
+/**
+ * Per-framework shortcut contributions. A framework that adds shortcuts lists
+ * them here (manifest) AND registers `ShortcutExtension(...)` in its view
+ * (runtime binding); both are gated by its flag. No framework ships shortcuts
+ * yet — the seam is ready and the manifest currently returns core only.
+ */
+const FRAMEWORK_SHORTCUT_GROUPS = [];
+const toEntry = (d) => ({
+    id: d.id,
+    labelKey: d.labelKey,
+    defaultKeys: d.defaultKeys,
+    scope: d.scope,
+    owner: d.owner,
+    when: d.when,
+});
+/**
+ * Pure aggregator (exported for testing): core shortcuts plus the shortcuts of
+ * every framework group whose flag is enabled.
+ */
+export function buildShortcutManifest(core, groups, flags) {
+    const entries = core.map(toEntry);
+    for (const { owner, shortcuts } of groups) {
+        if (isBlockEnabled(flags, owner)) {
+            entries.push(...shortcuts.map(toEntry));
+        }
+    }
+    return entries;
+}
+/**
+ * The enumerable shortcut manifest for a given flag set: core shortcuts plus
+ * the shortcuts contributed by the currently-enabled frameworks. Enumerable
+ * without an editor instance (for a settings panel). Mirrors the flag gating of
+ * `getInternalViewExtensions`.
+ */
+export function getShortcutManifest(flags) {
+    return buildShortcutManifest(coreShortcuts, FRAMEWORK_SHORTCUT_GROUPS, flags);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-core",
   "description": "Labre editor — the full BlockSuite-derived editor as one package.",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -810,6 +810,10 @@
       "types": "./dist/flags.d.ts",
       "import": "./dist/flags.js"
     },
+    "./shortcuts": {
+      "types": "./dist/shortcuts.d.ts",
+      "import": "./dist/shortcuts.js"
+    },
     "./model": {
       "types": "./dist/model/index.d.ts",
       "import": "./dist/model/index.js"

package/dist/_pkgs/affine-gfx-link/link-tool.d.ts

@@ -1 +0,0 @@
-export declare const linkQuickTool: import("../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-link/link-tool.js

@@ -1,11 +0,0 @@
-import { QuickToolExtension } from '../affine-widget-edgeless-toolbar/index.js';
-import { html } from 'lit';
-import { buildLinkDenseMenu } from './toolbar/link-dense-menu';
-export const linkQuickTool = QuickToolExtension('link', ({ block, gfx }) => {
-    return {
-        content: html `<edgeless-link-tool-button
-      .edgeless=${block}
-    ></edgeless-link-tool-button>`,
-        menu: buildLinkDenseMenu(block, gfx),
-    };
-});

package/dist/_pkgs/affine-gfx-link/toolbar/link-dense-menu.d.ts

@@ -1,2 +0,0 @@
-import type { DenseMenuBuilder } from '../../affine-widget-edgeless-toolbar/index.js';
-export declare const buildLinkDenseMenu: DenseMenuBuilder;

package/dist/_pkgs/affine-gfx-link/toolbar/link-dense-menu.js

@@ -1,26 +0,0 @@
-import { insertLinkByQuickSearchCommand } from '../../affine-block-bookmark/index.js';
-import { menu } from '../../affine-components/context-menu/index.js';
-import { LinkIcon } from '../../affine-components/icons/index.js';
-import { TelemetryProvider } from '../../affine-shared/services/index.js';
-export const buildLinkDenseMenu = edgeless => menu.action({
-    name: 'Link',
-    prefix: LinkIcon,
-    select: () => {
-        const [_, { insertedLinkType }] = edgeless.std.command.exec(insertLinkByQuickSearchCommand);
-        insertedLinkType
-            ?.then(type => {
-            const flavour = type?.flavour;
-            if (!flavour)
-                return;
-            edgeless.std
-                .getOptional(TelemetryProvider)
-                ?.track('CanvasElementAdded', {
-                control: 'toolbar:general',
-                page: 'whiteboard editor',
-                module: 'toolbar',
-                type: flavour.split(':')[1],
-            });
-        })
-            .catch(console.error);
-    },
-});

package/dist/_pkgs/affine-gfx-link/toolbar/link-tool-button.d.ts

@@ -1,10 +0,0 @@
-import { DefaultTool } from '../../affine-block-surface/index.js';
-import { LitElement } from 'lit';
-declare const EdgelessLinkToolButton_base: typeof LitElement & import("../../global/utils/types.js").Constructor<import("../../affine-widget-edgeless-toolbar/index.js").QuickToolMixinClass>;
-export declare class EdgelessLinkToolButton extends EdgelessLinkToolButton_base {
-    static styles: import("lit").CSSResult;
-    type: typeof DefaultTool;
-    private _onClick;
-    render(): import("lit-html").TemplateResult<1>;
-}
-export {};

package/dist/_pkgs/affine-gfx-link/toolbar/link-tool-button.js

@@ -1,84 +0,0 @@
-import { insertLinkByQuickSearchCommand } from '../../affine-block-bookmark/index.js';
-import { insertEmbedCard } from '../../affine-block-embed/index.js';
-import { DefaultTool } from '../../affine-block-surface/index.js';
-import { toggleEmbedCardCreateModal } from '../../affine-components/embed-card-modal/index.js';
-import { LinkIcon } from '../../affine-components/icons/index.js';
-import { TelemetryProvider } from '../../affine-shared/services/index.js';
-import { QuickToolMixin } from '../../affine-widget-edgeless-toolbar/index.js';
-import { GfxControllerIdentifier } from '../../std/gfx/index.js';
-import { css, html, LitElement } from 'lit';
-export class EdgelessLinkToolButton extends QuickToolMixin(LitElement) {
-    constructor() {
-        super(...arguments);
-        this.type = DefaultTool;
-    }
-    static { this.styles = css `
-    .link-icon,
-    .link-icon > svg {
-      width: 24px;
-      height: 24px;
-    }
-  `; }
-    _onClick() {
-        const [success, { insertedLinkType }] = this.edgeless.std.command.exec(insertLinkByQuickSearchCommand);
-        if (!success) {
-            // fallback to create a bookmark block with input modal
-            toggleEmbedCardCreateModal(this.edgeless.host, 'Links', 'The added link will be displayed as a card view.', {
-                mode: 'edgeless',
-                onSave: url => {
-                    insertEmbedCard(this.edgeless.std, {
-                        flavour: 'affine:bookmark',
-                        targetStyle: 'vertical',
-                        props: { url },
-                    });
-                },
-            }, ({ mode }) => {
-                if (mode === 'edgeless') {
-                    const gfx = this.edgeless.std.get(GfxControllerIdentifier);
-                    gfx.tool.setTool(DefaultTool);
-                }
-            }).catch(console.error);
-            return;
-        }
-        insertedLinkType
-            ?.then(type => {
-            const flavour = type?.flavour;
-            if (!flavour)
-                return;
-            this.edgeless.std
-                .getOptional(TelemetryProvider)
-                ?.track('CanvasElementAdded', {
-                control: 'toolbar:general',
-                page: 'whiteboard editor',
-                module: 'toolbar',
-                segment: 'toolbar',
-                type: flavour.split(':')[1],
-            });
-            this.edgeless.std
-                .getOptional(TelemetryProvider)
-                ?.track('LinkedDocCreated', {
-                control: 'links',
-                page: 'whiteboard editor',
-                module: 'edgeless toolbar',
-                segment: 'whiteboard',
-                type: flavour.split(':')[1],
-                other: 'existing doc',
-            });
-        })
-            .catch(console.error);
-    }
-    render() {
-        return html `<edgeless-tool-icon-button
-      .iconContainerPadding="${6}"
-      .tooltip="${html `<affine-tooltip-content-with-shortcut
-        data-tip="${'Link'}"
-        data-shortcut="${'@'}"
-      ></affine-tooltip-content-with-shortcut>`}"
-      .tooltipOffset=${17}
-      class="edgeless-link-tool-button"
-      @click=${this._onClick}
-    >
-      <span class="link-icon">${LinkIcon}</span>
-    </edgeless-tool-icon-button>`;
-    }
-}