@formicoidea/labre-core 0.30.1 → 0.32.0

package/dist/_pkgs/affine-widget-linked-doc/transformers/markdown.js

@@ -3,7 +3,131 @@ import { Container } from '../../global/di/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
 import { sha } from '../../global/utils/index.js';
 import { extMimeMap, Transformer } from '../../store/index.js';
-import { createAssetsArchive, download, Unzip } from './utils.js';
+import { createAssetsArchive, download, parseMatter, Unzip, } from './utils.js';
+/**
+ * The spellings the tools people export markdown from actually use. Anything
+ * else in the frontmatter is metadata we have no field for, and is dropped.
+ */
+const FRONTMATTER_KEYS = {
+    title: ['title', 'name'],
+    created: [
+        'created',
+        'createdat',
+        'created_at',
+        'createddate',
+        'created_date',
+        'creationdate',
+        'date',
+        'time',
+    ],
+    updated: [
+        'updated',
+        'updatedat',
+        'updated_at',
+        'updateddate',
+        'updated_date',
+        'modified',
+        'modifiedat',
+        'modified_at',
+        'lastmodified',
+        'last_modified',
+        'lastedited',
+        'last_edited',
+        'lasteditedtime',
+        'last_edited_time',
+    ],
+    tags: ['tags', 'tag', 'categories', 'category', 'labels', 'keywords'],
+    favorite: ['favorite', 'favourite', 'star', 'starred', 'pinned'],
+};
+const truthyStrings = new Set(['true', 'yes', 'y', '1', 'on']);
+const falsyStrings = new Set(['false', 'no', 'n', '0', 'off']);
+function parseBoolean(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (truthyStrings.has(normalized))
+        return true;
+    if (falsyStrings.has(normalized))
+        return false;
+    return undefined;
+}
+function parseTimestamp(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const seconds = Number(value);
+    if (value.trim() && !Number.isNaN(seconds)) {
+        // A bare number is an epoch: in seconds unless it is far too large for one.
+        return seconds > 1e10 ? seconds : Math.round(seconds * 1000);
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function parseTags(value) {
+    const tags = (Array.isArray(value) ? value : value.split(/[,;]+/))
+        .map(tag => tag.trim())
+        .filter(Boolean);
+    return tags.length ? [...new Set(tags)] : undefined;
+}
+function buildMetaFromFrontmatter(data) {
+    const meta = {};
+    for (const [rawKey, value] of Object.entries(data)) {
+        const key = rawKey.trim().toLowerCase();
+        if (FRONTMATTER_KEYS.title.includes(key) && typeof value === 'string') {
+            const title = value.trim();
+            if (title)
+                meta.title = title;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.created.includes(key)) {
+            const timestamp = parseTimestamp(value);
+            if (timestamp !== undefined)
+                meta.createDate = timestamp;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.updated.includes(key)) {
+            const timestamp = parseTimestamp(value);
+            if (timestamp !== undefined)
+                meta.updatedDate = timestamp;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.tags.includes(key)) {
+            const tags = parseTags(value);
+            if (tags)
+                meta.tags = tags;
+            continue;
+        }
+        if (FRONTMATTER_KEYS.favorite.includes(key)) {
+            const favorite = parseBoolean(value);
+            if (favorite !== undefined)
+                meta.favorite = favorite;
+        }
+    }
+    return meta;
+}
+/**
+ * Read the frontmatter off a markdown file and hand back the content without
+ * it, so the metadata never lands in the document as a paragraph of its own.
+ */
+export function parseFrontmatter(markdown) {
+    try {
+        const parsed = parseMatter(markdown);
+        if (!parsed) {
+            return { content: markdown, meta: {} };
+        }
+        return {
+            content: parsed.body,
+            meta: buildMetaFromFrontmatter(parsed.metadata),
+        };
+    }
+    catch {
+        return { content: markdown, meta: {} };
+    }
+}
+function applyMetaPatch(collection, docId, meta) {
+    if (Object.keys(meta).length) {
+        collection.meta.setDocMeta(docId, meta);
+    }
+}
 function getProvider(extensions) {
     const container = new Container();
     extensions.forEach(ext => {
@@ -90,6 +214,7 @@ async function importMarkdownToBlock({ doc, markdown, blockId, extensions, }) {
  * @returns A Promise that resolves to the ID of the newly created doc, or undefined if import fails
  */
 async function importMarkdownToDoc({ collection, schema, markdown, fileName, extensions, }) {
+    const { content, meta } = parseFrontmatter(markdown);
     const provider = getProvider(extensions);
     const job = new Transformer({
         schema,
@@ -101,18 +226,19 @@ async function importMarkdownToDoc({ collection, schema, markdown, fileName, ext
         },
         middlewares: [
             defaultImageProxyMiddleware,
-            fileNameMiddleware(fileName),
+            fileNameMiddleware(meta.title ?? fileName),
             docLinkBaseURLMiddleware(collection.id),
         ],
     });
     const mdAdapter = new MarkdownAdapter(job, provider);
     const page = await mdAdapter.toDoc({
-        file: markdown,
+        file: content,
         assets: job.assetsManager,
     });
     if (!page) {
         return;
     }
+    applyMetaPatch(collection, page.id, meta);
     return page.id;
 }
 /**
@@ -159,6 +285,7 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
     await Promise.all(markdownBlobs.map(async (markdownFile) => {
         const { filename, contentBlob, fullPath } = markdownFile;
         const fileNameWithoutExt = filename.replace(/\.[^/.]+$/, '');
+        const { content, meta } = parseFrontmatter(await contentBlob.text());
         const job = new Transformer({
             schema,
             blobCRUD: collection.blobSync,
@@ -169,7 +296,7 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
             },
             middlewares: [
                 defaultImageProxyMiddleware,
-                fileNameMiddleware(fileNameWithoutExt),
+                fileNameMiddleware(meta.title ?? fileNameWithoutExt),
                 docLinkBaseURLMiddleware(collection.id),
                 filePathMiddleware(fullPath),
             ],
@@ -188,12 +315,12 @@ async function importMarkdownZip({ collection, schema, imported, extensions, })
             }
         }
         const mdAdapter = new MarkdownAdapter(job, provider);
-        const markdown = await contentBlob.text();
         const doc = await mdAdapter.toDoc({
-            file: markdown,
+            file: content,
             assets: job.assetsManager,
         });
         if (doc) {
+            applyMetaPatch(collection, doc.id, meta);
             docIds.push(doc.id);
         }
     }));

package/dist/_pkgs/affine-widget-linked-doc/transformers/utils.d.ts

@@ -21,4 +21,14 @@ export declare class Unzip {
     }, void, unknown>;
 }
 export declare function createAssetsArchive(assetsMap: Map<string, Blob>, assetsIds: string[]): Promise<Zip>;
+export type FrontmatterValue = string | string[];
+/**
+ * Split a markdown file into its frontmatter metadata and the content below,
+ * or `null` when it opens with no frontmatter at all.
+ */
+export declare const parseMatter: (contents: string) => {
+    matter: string;
+    body: string;
+    metadata: Record<string, FrontmatterValue>;
+} | null;
 export declare function download(blob: Blob, name: string): void;

package/dist/_pkgs/affine-widget-linked-doc/transformers/utils.js

@@ -52,6 +52,42 @@ export class Zip {
         });
     }
 }
+const strictUtf8Decoder = new TextDecoder('utf-8', { fatal: true });
+/**
+ * Repair an entry name that was decoded as Latin-1.
+ *
+ * fflate follows the zip spec: unless an entry sets the UTF-8 flag (general
+ * purpose bit 11) its name is decoded as Latin-1. Common archivers — the macOS
+ * `zip` tool among them — write UTF-8 bytes without ever setting that flag, so
+ * a CJK name comes back as mojibake, one character per raw byte.
+ *
+ * Such a name only ever holds code points in the 0x00-0xff range, so it can be
+ * turned back into the original bytes and decoded again, strictly, as UTF-8.
+ * Anything that is not valid UTF-8 — a name that really was Latin-1, or one
+ * fflate already decoded correctly — is left untouched.
+ */
+function fixFileNameEncoding(fileName) {
+    const bytes = new Uint8Array(fileName.length);
+    let hasNonAscii = false;
+    for (let i = 0; i < fileName.length; i++) {
+        const code = fileName.charCodeAt(i);
+        // A code point above 0xff cannot come out of a Latin-1 decode: the name was
+        // already decoded from its declared UTF-8 bytes, nothing to repair.
+        if (code > 0xff)
+            return fileName;
+        if (code > 0x7f)
+            hasNonAscii = true;
+        bytes[i] = code;
+    }
+    if (!hasNonAscii)
+        return fileName;
+    try {
+        return strictUtf8Decoder.decode(bytes);
+    }
+    catch {
+        return fileName;
+    }
+}
 export class Unzip {
     async load(blob) {
         this.unzipped = fflate.unzipSync(new Uint8Array(await blob.arrayBuffer()));
@@ -60,15 +96,17 @@ export class Unzip {
         const keys = Object.keys(this.unzipped ?? {});
         let index = 0;
         while (keys.length) {
-            const path = keys.shift();
-            if (path.includes('__MACOSX') || path.includes('DS_Store')) {
+            const rawPath = keys.shift();
+            if (rawPath.includes('__MACOSX') || rawPath.includes('DS_Store')) {
                 continue;
             }
+            const data = this.unzipped[rawPath];
+            const path = fixFileNameEncoding(rawPath);
             const lastSplitIndex = path.lastIndexOf('/');
             const fileName = path.substring(lastSplitIndex + 1);
             const fileExt = fileName.lastIndexOf('.') === -1 ? '' : fileName.split('.').at(-1);
             const mime = extMimeMap.get(fileExt ?? '');
-            const content = new File([this.unzipped[path]], fileName, {
+            const content = new File([data], fileName, {
                 type: mime ?? '',
             });
             yield { path, content, index };
@@ -86,6 +124,85 @@ export async function createAssetsArchive(assetsMap, assetsIds) {
     }
     return zip;
 }
+/**
+ * A frontmatter block, and only at the very top of the file: a `---` further
+ * down is a horizontal rule and the reader expects to see it.
+ */
+const FRONTMATTER = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+const unquote = (value) => {
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if (trimmed.length >= 2 &&
+        (quote === '"' || quote === "'") &&
+        trimmed.endsWith(quote)) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+};
+/**
+ * Parse the flat subset of YAML a frontmatter block actually uses: `key: value`
+ * pairs, flow sequences (`tags: [a, b]`) and block sequences. Every scalar
+ * stays a string — the caller knows which of them is a date, a flag or a list,
+ * and a full YAML parser would only add a dependency to guess it for us.
+ * Nested mappings are ignored rather than flattened.
+ */
+const parseFrontmatterBody = (source) => {
+    const data = {};
+    let listKey = null;
+    for (const line of source.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const item = trimmed.match(/^-\s+(.*)$/);
+        if (item && listKey) {
+            const list = data[listKey];
+            const value = unquote(item[1]);
+            if (Array.isArray(list))
+                list.push(value);
+            else
+                data[listKey] = [value];
+            continue;
+        }
+        // Keys are read at the top level only, so an indented mapping under a key
+        // does not silently become a sibling of it.
+        const entry = line.match(/^([A-Za-z0-9_][A-Za-z0-9_ -]*):(.*)$/);
+        if (!entry) {
+            listKey = null;
+            continue;
+        }
+        const key = entry[1].trim();
+        const value = entry[2].trim();
+        listKey = null;
+        if (!value) {
+            // Either a block sequence follows, or a nested mapping we will ignore.
+            data[key] = [];
+            listKey = key;
+            continue;
+        }
+        const flow = value.match(/^\[(.*)\]$/);
+        data[key] = flow
+            ? flow[1].split(',').map(unquote).filter(Boolean)
+            : unquote(value);
+    }
+    return Object.keys(data).length ? data : null;
+};
+/**
+ * Split a markdown file into its frontmatter metadata and the content below,
+ * or `null` when it opens with no frontmatter at all.
+ */
+export const parseMatter = (contents) => {
+    const match = contents.match(FRONTMATTER);
+    if (!match)
+        return null;
+    const metadata = parseFrontmatterBody(match[1]);
+    if (!metadata)
+        return null;
+    return {
+        matter: match[1],
+        body: contents.slice(match[0].length),
+        metadata,
+    };
+};
 export function download(blob, name) {
     const element = document.createElement('a');
     element.setAttribute('download', name);

package/dist/_pkgs/affine-widget-linked-doc/utils.d.ts

@@ -1,2 +1,14 @@
 import { Signal } from '@preact/signals-core';
 export declare function resolveSignal<T>(data: T | Signal<T>): T;
+/**
+ * The keydown interceptor of the linked-doc popover.
+ *
+ * The shared keydown observer treats "a modifier plus any other key" as a
+ * reason to abort, so every key the popover wants to survive has to be caught
+ * here first — which is why changing the OS keyboard LAYOUT used to close the
+ * popover: on Windows and Linux, Alt+Shift arrives as a keydown whose `key` is
+ * `GroupNext` or `GroupPrevious`, and that reads as modifier + key.
+ *
+ * @param close - what `Escape` does; the popover's own `close`.
+ */
+export declare function createLinkedDocKeydownInterceptor(close: () => void): (event: KeyboardEvent, next: () => void) => void;

package/dist/_pkgs/affine-widget-linked-doc/utils.js

@@ -2,3 +2,36 @@ import { Signal } from '@preact/signals-core';
 export function resolveSignal(data) {
     return data instanceof Signal ? data.value : data;
 }
+/**
+ * The keydown interceptor of the linked-doc popover.
+ *
+ * The shared keydown observer treats "a modifier plus any other key" as a
+ * reason to abort, so every key the popover wants to survive has to be caught
+ * here first — which is why changing the OS keyboard LAYOUT used to close the
+ * popover: on Windows and Linux, Alt+Shift arrives as a keydown whose `key` is
+ * `GroupNext` or `GroupPrevious`, and that reads as modifier + key.
+ *
+ * @param close - what `Escape` does; the popover's own `close`.
+ */
+export function createLinkedDocKeydownInterceptor(close) {
+    return (event, next) => {
+        if (event.key === 'GroupNext' || event.key === 'GroupPrevious') {
+            // The user switched keyboard layout, not documents. Swallow it and leave
+            // the query, the selection and the popover exactly as they were.
+            event.stopPropagation();
+            return;
+        }
+        if (event.key === 'ArrowRight' || event.key === 'ArrowLeft') {
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+        }
+        if (event.key === 'Escape') {
+            close();
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+        }
+        next();
+    };
+}

package/dist/_pkgs/affine-widget-linked-doc/view.d.ts

@@ -2,7 +2,7 @@ import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-
 import type { AffineInlineEditor } from '../affine-shared/types/index.js';
 import type { EditorHost } from '../std/index.js';
 import { z } from 'zod';
-import { type LinkedMenuGroup } from './config';
+import { type LinkedMenuGroup } from './config.js';
 declare const optionsSchema: z.ZodObject<{
     triggerKeys: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
     convertTriggerKey: z.ZodOptional<z.ZodBoolean>;

package/dist/_pkgs/affine-widget-linked-doc/view.js

@@ -1,8 +1,8 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { z } from 'zod';
-import { LinkedWidgetConfigExtension } from './config';
-import { effects } from './effects';
-import { linkedDocWidget } from './widget';
+import { LinkedWidgetConfigExtension } from './config.js';
+import { effects } from './effects.js';
+import { linkedDocWidget } from './widget.js';
 const optionsSchema = z.object({
     triggerKeys: z.optional(z.tuple([z.string()]).rest(z.string())),
     convertTriggerKey: z.boolean().optional(),

package/dist/_pkgs/affine-widget-note-slicer/effects.js

@@ -1,4 +1,4 @@
-import { NOTE_SLICER_WIDGET, NoteSlicer } from './note-slicer';
+import { NOTE_SLICER_WIDGET, NoteSlicer } from './note-slicer.js';
 export function effects() {
     customElements.define(NOTE_SLICER_WIDGET, NoteSlicer);
 }

package/dist/_pkgs/affine-widget-note-slicer/index.d.ts

@@ -1 +1 @@
-export * from './note-slicer';
+export * from './note-slicer.js';

package/dist/_pkgs/affine-widget-note-slicer/index.js

@@ -1 +1 @@
-export * from './note-slicer';
+export * from './note-slicer.js';

package/dist/_pkgs/affine-widget-note-slicer/view.js

@@ -1,6 +1,6 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { effects } from './effects';
-import { noteSlicerWidget } from './note-slicer';
+import { effects } from './effects.js';
+import { noteSlicerWidget } from './note-slicer.js';
 export class NoteSlicerViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);

package/dist/_pkgs/affine-widget-page-dragging-area/effects.js

@@ -1,4 +1,4 @@
-import { AFFINE_PAGE_DRAGGING_AREA_WIDGET, AffinePageDraggingAreaWidget, } from './index';
+import { AFFINE_PAGE_DRAGGING_AREA_WIDGET, AffinePageDraggingAreaWidget, } from './index.js';
 export function effects() {
     customElements.define(AFFINE_PAGE_DRAGGING_AREA_WIDGET, AffinePageDraggingAreaWidget);
 }

package/dist/_pkgs/affine-widget-page-dragging-area/index.d.ts

@@ -1,7 +1,7 @@
 import type { RootBlockModel } from '../affine-model/index.js';
 import { WidgetComponent } from '../std/index.js';
 import { nothing } from 'lit';
-import { type Rect } from './utils';
+import { type Rect } from './utils.js';
 export declare const AFFINE_PAGE_DRAGGING_AREA_WIDGET = "affine-page-dragging-area-widget";
 export declare class AffinePageDraggingAreaWidget extends WidgetComponent<RootBlockModel> {
     static excludeFlavours: string[];

package/dist/_pkgs/affine-widget-page-dragging-area/index.js

@@ -39,7 +39,7 @@ import { html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
 import { literal, unsafeStatic } from 'lit/static-html.js';
-import { getSelectingBlockPaths, isDragArea, } from './utils';
+import { getSelectingBlockPaths, isDragArea, } from './utils.js';
 export const AFFINE_PAGE_DRAGGING_AREA_WIDGET = 'affine-page-dragging-area-widget';
 let AffinePageDraggingAreaWidget = (() => {
     let _classSuper = WidgetComponent;

package/dist/_pkgs/affine-widget-page-dragging-area/view.js

@@ -1,6 +1,6 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { effects } from './effects';
-import { pageDraggingAreaWidget } from './index';
+import { effects } from './effects.js';
+import { pageDraggingAreaWidget } from './index.js';
 export class PageDraggingAreaViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);

package/dist/_pkgs/affine-widget-remote-selection/doc/doc-remote-selection.js

@@ -42,9 +42,9 @@ import { computed, effect } from '@preact/signals-core';
 import { css, html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
-import throttle from 'lodash-es/throttle';
-import { RemoteColorManager } from '../manager/remote-color-manager';
-import { cursorStyle, selectionStyle } from './utils';
+import throttle from 'lodash-es/throttle.js';
+import { RemoteColorManager } from '../manager/remote-color-manager.js';
+import { cursorStyle, selectionStyle } from './utils.js';
 export const AFFINE_DOC_REMOTE_SELECTION_WIDGET = 'affine-doc-remote-selection-widget';
 let AffineDocRemoteSelectionWidget = (() => {
     let _classSuper = WidgetComponent;

package/dist/_pkgs/affine-widget-remote-selection/edgeless/index.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
-import { getSelectedRect, isTopLevelBlock, requestThrottledConnectedFrame, } from '../../affine-shared/utils/index.js';
+import { getSelectedRect, isTopLevelBlock, overlayScale, requestThrottledConnectedFrame, } from '../../affine-shared/utils/index.js';
 import { MultiCursorDuotoneIcon } from '@blocksuite/icons/lit';
 import { WidgetComponent } from '../../std/index.js';
 import { GfxControllerIdentifier } from '../../std/gfx/index.js';
@@ -41,7 +41,7 @@ import { css, html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
-import { RemoteColorManager } from '../manager/remote-color-manager';
+import { RemoteColorManager } from '../manager/remote-color-manager.js';
 export const AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET = 'affine-edgeless-remote-selection-widget';
 let EdgelessRemoteSelectionWidget = (() => {
     let _classSuper = WidgetComponent;
@@ -252,9 +252,11 @@ let EdgelessRemoteSelectionWidget = (() => {
                 this._remoteRects = remoteRects;
             };
             this._updateTransform = requestThrottledConnectedFrame(() => {
-                const { translateX, translateY, zoom } = this.gfx.viewport;
-                this.style.setProperty('--v-zoom', `${zoom}`);
-                this.style.setProperty('transform', `translate(${translateX}px, ${translateY}px) scale(var(--v-zoom))`);
+                const { translateX, translateY, viewScale } = this.gfx.viewport;
+                // Stated in the scaled space of the container, like every other overlay
+                // and like `GfxBlockComponent.getCSSTransform`.
+                this.style.setProperty('--v-zoom', `${overlayScale(this.gfx.viewport)}`);
+                this.style.setProperty('transform', `translate(${translateX / viewScale}px, ${translateY / viewScale}px) scale(var(--v-zoom))`);
             }, this);
             this.#_remoteCursors_accessor_storage = __runInitializers(this, __remoteCursors_initializers, new Map());
             this.#_remoteRects_accessor_storage = (__runInitializers(this, __remoteCursors_extraInitializers), __runInitializers(this, __remoteRects_initializers, new Map()));

package/dist/_pkgs/affine-widget-remote-selection/effects.js

@@ -1,6 +1,6 @@
-import { AFFINE_DOC_REMOTE_SELECTION_WIDGET } from './doc';
-import { AffineDocRemoteSelectionWidget } from './doc/doc-remote-selection';
-import { AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET, EdgelessRemoteSelectionWidget, } from './edgeless';
+import { AFFINE_DOC_REMOTE_SELECTION_WIDGET } from './doc/index.js';
+import { AffineDocRemoteSelectionWidget } from './doc/doc-remote-selection.js';
+import { AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET, EdgelessRemoteSelectionWidget, } from './edgeless/index.js';
 export function effects() {
     customElements.define(AFFINE_DOC_REMOTE_SELECTION_WIDGET, AffineDocRemoteSelectionWidget);
     customElements.define(AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET, EdgelessRemoteSelectionWidget);

package/dist/_pkgs/affine-widget-remote-selection/index.d.ts

@@ -1,4 +1,4 @@
-export * from './doc';
-export * from './edgeless';
+export * from './doc/index.js';
+export * from './edgeless/index.js';
 export declare const docRemoteSelectionWidget: import("../store/index.js").ExtensionType;
 export declare const edgelessRemoteSelectionWidget: import("../store/index.js").ExtensionType;

package/dist/_pkgs/affine-widget-remote-selection/index.js

@@ -1,8 +1,8 @@
 import { WidgetViewExtension } from '../std/index.js';
 import { literal, unsafeStatic } from 'lit/static-html.js';
-import { AFFINE_DOC_REMOTE_SELECTION_WIDGET } from './doc';
-import { AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET } from './edgeless';
-export * from './doc';
-export * from './edgeless';
+import { AFFINE_DOC_REMOTE_SELECTION_WIDGET } from './doc/index.js';
+import { AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET } from './edgeless/index.js';
+export * from './doc/index.js';
+export * from './edgeless/index.js';
 export const docRemoteSelectionWidget = WidgetViewExtension('affine:page', AFFINE_DOC_REMOTE_SELECTION_WIDGET, literal `${unsafeStatic(AFFINE_DOC_REMOTE_SELECTION_WIDGET)}`);
 export const edgelessRemoteSelectionWidget = WidgetViewExtension('affine:page', AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET, literal `${unsafeStatic(AFFINE_EDGELESS_REMOTE_SELECTION_WIDGET)}`);

package/dist/_pkgs/affine-widget-remote-selection/manager/remote-color-manager.js

@@ -1,5 +1,5 @@
 import { EditPropsStore } from '../../affine-shared/services/index.js';
-import { multiPlayersColor } from './color-picker';
+import { multiPlayersColor } from './color-picker.js';
 export class RemoteColorManager {
     get awarenessStore() {
         return this.std.store.awarenessStore;

package/dist/_pkgs/affine-widget-remote-selection/view.js

@@ -1,6 +1,6 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { effects } from './effects';
-import { docRemoteSelectionWidget, edgelessRemoteSelectionWidget, } from './index';
+import { effects } from './effects.js';
+import { docRemoteSelectionWidget, edgelessRemoteSelectionWidget, } from './index.js';
 export class RemoteSelectionViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);

package/dist/_pkgs/affine-widget-scroll-anchoring/view.js

@@ -1,6 +1,6 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { effects } from './effects';
-import { scrollAnchoringWidget } from './index';
+import { effects } from './effects.js';
+import { scrollAnchoringWidget } from './index.js';
 export class ScrollAnchoringViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);

package/dist/_pkgs/affine-widget-slash-menu/config.d.ts

@@ -1,2 +1,2 @@
-import type { SlashMenuConfig } from './types';
+import type { SlashMenuConfig } from './types.js';
 export declare const defaultSlashMenuConfig: SlashMenuConfig;

package/dist/_pkgs/affine-widget-slash-menu/config.js

@@ -2,8 +2,8 @@ import { toast } from '../affine-components/toast/index.js';
 import { insertContent } from '../affine-rich-text/index.js';
 import { ArrowDownBigIcon, ArrowUpBigIcon, CopyIcon, DeleteIcon, DualLinkIcon, NowIcon, TodayIcon, TomorrowIcon, YesterdayIcon, } from '@blocksuite/icons/lit';
 import { Slice, Text } from '../store/index.js';
-import { slashMenuToolTips } from './tooltips';
-import { formatDate, formatTime } from './utils';
+import { slashMenuToolTips } from './tooltips/index.js';
+import { formatDate, formatTime } from './utils.js';
 export const defaultSlashMenuConfig = {
     items: () => {
         const now = new Date();

package/dist/_pkgs/affine-widget-slash-menu/effects.d.ts

@@ -1,5 +1,5 @@
-import { AFFINE_SLASH_MENU_WIDGET } from './consts';
-import { AffineSlashMenuWidget } from './widget';
+import { AFFINE_SLASH_MENU_WIDGET } from './consts.js';
+import { AffineSlashMenuWidget } from './widget.js';
 export declare function effects(): void;
 declare global {
     interface HTMLElementTagNameMap {

package/dist/_pkgs/affine-widget-slash-menu/effects.js

@@ -1,6 +1,6 @@
-import { AFFINE_SLASH_MENU_WIDGET } from './consts';
-import { InnerSlashMenu, SlashMenu } from './slash-menu-popover';
-import { AffineSlashMenuWidget } from './widget';
+import { AFFINE_SLASH_MENU_WIDGET } from './consts.js';
+import { InnerSlashMenu, SlashMenu } from './slash-menu-popover.js';
+import { AffineSlashMenuWidget } from './widget.js';
 export function effects() {
     customElements.define(AFFINE_SLASH_MENU_WIDGET, AffineSlashMenuWidget);
     customElements.define('affine-slash-menu', SlashMenu);