@formicoidea/labre-core 0.43.1 → 0.45.0

package/dist/_pkgs/std/gfx/model/surface/user-layers.d.ts

@@ -0,0 +1,68 @@
+import type { Store } from '../../../../store/index.js';
+import type { GfxModel } from '../model.js';
+import type { SurfaceBlockModel } from './surface-model.js';
+/**
+ * The layer every element belongs to while it names none (ADR 0031 §2, §3).
+ * A `@` cannot appear in a nanoid, so it never collides with a real layer id;
+ * it has no record while the surface has no `layers`, and is written as
+ * `undefined` on an element, never as this string.
+ */
+export declare const DEFAULT_LAYER_ID = "@default";
+/** One user layer, stored on the surface under its id (ADR 0031 §2). */
+export type SurfaceLayerRecord = {
+    /** Seeded through the translation seam at creation; content from then on. */
+    name: string;
+    /** Fractional key, bottom → top; the same alphabet as an element's `index`. */
+    index: string;
+    /** "Hide for everyone" on the whole layer. Absent = visible. */
+    hidden?: true;
+};
+/**
+ * What a model names as its own layer: an element's `layer` field, a gfx
+ * block's `layer` prop. `undefined` = the default layer.
+ */
+export declare function ownLayerOf(model: unknown): string | undefined;
+/**
+ * The model whose `layer` decides `model`'s (ADR 0031 §5): its outermost
+ * group-like ELEMENT ancestor (a group, a mindmap), else `model` itself. A
+ * group lives in one layer, stored once on its outermost group, so this is
+ * what {@link SurfaceUserLayers.effectiveLayerOf} reads and what a "move to
+ * layer" writes on. Frames are blocks and do not count. `groups` walks the
+ * model's surface, which throws on a detached model: that one carries itself.
+ */
+export declare function layerCarrierOf(model: GfxModel): GfxModel;
+/**
+ * The user layers of one surface, resolved for the comparator (ADR 0031 §4).
+ *
+ * Two caches, both thrown away by a revision bump rather than kept in step:
+ *
+ * - the rank of every layer id (its record's `index`), rebuilt when the
+ *   `layers` prop changes — `null` while the surface has no layer, which is
+ *   the fast path: `compare` then never asks for an effective layer at all;
+ * - each model's EFFECTIVE layer, rebuilt when anything that decides it
+ *   changes: a `layer` write, a regroup, an element added or removed.
+ *
+ * The effective layer is the `layer` of the model's outermost group-like
+ * ELEMENT ancestor (a group, a mindmap), else its own; a dangling id or none
+ * is {@link DEFAULT_LAYER_ID}. Frames are not counted: a frame is a slide,
+ * and a background layer under a content layer inside one frame is the point
+ * of layers. Nothing here writes: a dangling id is read as the default and
+ * left as it is.
+ */
+export declare class SurfaceUserLayers {
+    private readonly _surface;
+    private _ranks;
+    private _revision;
+    private readonly _effective;
+    constructor(_surface: SurfaceBlockModel);
+    /** Every layer id with its rank key, or `null` when there is no layer. */
+    get ranks(): ReadonlyMap<string, string> | null;
+    /** The `layers` record changed: ranks and effective layers are stale. */
+    invalidateRanks(): void;
+    /** Something that decides an effective layer changed. */
+    invalidateMembership(): void;
+    /** The layer `model` stacks and shows with. */
+    effectiveLayerOf(model: GfxModel): string;
+}
+export declare function registerSurfaceOfStore(store: Store, surface: SurfaceBlockModel): void;
+export declare function userLayersOf(model: unknown): SurfaceUserLayers | null;

package/dist/_pkgs/std/gfx/model/surface/user-layers.js

@@ -0,0 +1,127 @@
+import { GfxPrimitiveElementModel } from './element-model.js';
+/**
+ * The layer every element belongs to while it names none (ADR 0031 §2, §3).
+ * A `@` cannot appear in a nanoid, so it never collides with a real layer id;
+ * it has no record while the surface has no `layers`, and is written as
+ * `undefined` on an element, never as this string.
+ */
+export const DEFAULT_LAYER_ID = '@default';
+/**
+ * What a model names as its own layer: an element's `layer` field, a gfx
+ * block's `layer` prop. `undefined` = the default layer.
+ */
+export function ownLayerOf(model) {
+    if (model instanceof GfxPrimitiveElementModel)
+        return model.layer;
+    try {
+        const props = model.props;
+        return typeof props?.layer === 'string' ? props.layer : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The model whose `layer` decides `model`'s (ADR 0031 §5): its outermost
+ * group-like ELEMENT ancestor (a group, a mindmap), else `model` itself. A
+ * group lives in one layer, stored once on its outermost group, so this is
+ * what {@link SurfaceUserLayers.effectiveLayerOf} reads and what a "move to
+ * layer" writes on. Frames are blocks and do not count. `groups` walks the
+ * model's surface, which throws on a detached model: that one carries itself.
+ */
+export function layerCarrierOf(model) {
+    let groups = [];
+    try {
+        groups = model.groups ?? [];
+    }
+    catch {
+        groups = [];
+    }
+    for (let i = groups.length - 1; i >= 0; i--) {
+        if (groups[i] instanceof GfxPrimitiveElementModel) {
+            return groups[i];
+        }
+    }
+    return model;
+}
+/**
+ * The user layers of one surface, resolved for the comparator (ADR 0031 §4).
+ *
+ * Two caches, both thrown away by a revision bump rather than kept in step:
+ *
+ * - the rank of every layer id (its record's `index`), rebuilt when the
+ *   `layers` prop changes — `null` while the surface has no layer, which is
+ *   the fast path: `compare` then never asks for an effective layer at all;
+ * - each model's EFFECTIVE layer, rebuilt when anything that decides it
+ *   changes: a `layer` write, a regroup, an element added or removed.
+ *
+ * The effective layer is the `layer` of the model's outermost group-like
+ * ELEMENT ancestor (a group, a mindmap), else its own; a dangling id or none
+ * is {@link DEFAULT_LAYER_ID}. Frames are not counted: a frame is a slide,
+ * and a background layer under a content layer inside one frame is the point
+ * of layers. Nothing here writes: a dangling id is read as the default and
+ * left as it is.
+ */
+export class SurfaceUserLayers {
+    constructor(_surface) {
+        this._surface = _surface;
+        this._ranks = undefined;
+        this._revision = 0;
+        this._effective = new WeakMap();
+    }
+    /** Every layer id with its rank key, or `null` when there is no layer. */
+    get ranks() {
+        if (this._ranks === undefined) {
+            const layers = this._surface.props.layers;
+            if (!layers || Object.keys(layers).length === 0) {
+                this._ranks = null;
+            }
+            else {
+                const ranks = new Map();
+                for (const [id, record] of Object.entries(layers)) {
+                    if (record && typeof record.index === 'string') {
+                        ranks.set(id, record.index);
+                    }
+                }
+                this._ranks = ranks.size ? ranks : null;
+            }
+        }
+        return this._ranks;
+    }
+    /** The `layers` record changed: ranks and effective layers are stale. */
+    invalidateRanks() {
+        this._ranks = undefined;
+        this._revision++;
+    }
+    /** Something that decides an effective layer changed. */
+    invalidateMembership() {
+        this._revision++;
+    }
+    /** The layer `model` stacks and shows with. */
+    effectiveLayerOf(model) {
+        const cached = this._effective.get(model);
+        if (cached && cached.revision === this._revision)
+            return cached.layer;
+        const named = ownLayerOf(layerCarrierOf(model));
+        const ranks = this.ranks;
+        const layer = named !== undefined && ranks?.has(named) ? named : DEFAULT_LAYER_ID;
+        this._effective.set(model, { revision: this._revision, layer });
+        return layer;
+    }
+}
+/**
+ * Which surface a model's layers are read from. An element knows its
+ * surface; a gfx block knows its store, and the surface registers itself for
+ * its store when it initialises, so the comparator never queries the store.
+ */
+const SURFACE_OF_STORE = new WeakMap();
+export function registerSurfaceOfStore(store, surface) {
+    SURFACE_OF_STORE.set(store, surface);
+}
+export function userLayersOf(model) {
+    if (model instanceof GfxPrimitiveElementModel) {
+        return model.surface?.userLayers ?? null;
+    }
+    const store = model.store;
+    return store ? (SURFACE_OF_STORE.get(store)?.userLayers ?? null) : null;
+}

package/dist/_pkgs/std/utils/layer.d.ts

@@ -8,6 +8,16 @@ export declare function getLayerEndZIndex(layers: Layer[], layerIndex: number):
 export declare function updateLayersZIndex(layers: Layer[], startIdx: number): void;
 export declare function getElementIndex(indexable: GfxModel): string;
 export declare function ungroupIndex(index: string): string;
+/**
+ * Insert `element` after every element that sorts before it or ties with it.
+ *
+ * The array is kept sorted by `compare`, so that predicate holds on a prefix
+ * and the position is found by bisection. The linear scan it replaces asked
+ * `compare` (which walks both elements' group chains) of every element on
+ * every insert: a paste of N elements was N² comparisons. Where an index is
+ * shared by two unrelated subtrees `compare` is not transitive and both pick
+ * a tied position, not always the same one (layer-ordered-insert.unit.spec).
+ */
 export declare function insertToOrderedArray(array: GfxModel[], element: GfxModel): void;
 export declare function removeFromOrderedArray(array: GfxModel[], element: GfxModel): void;
 export declare enum SortOrder {

package/dist/_pkgs/std/utils/layer.js

@@ -1,6 +1,7 @@
 import { isGfxGroupCompatibleModel, } from '../gfx/model/base.js';
 import {} from '../gfx/model/gfx-block-model.js';
 import { GfxLocalElementModel } from '../gfx/model/surface/local-element-model.js';
+import { userLayersOf } from '../gfx/model/surface/user-layers.js';
 export function getLayerEndZIndex(layers, layerIndex) {
     const layer = layers[layerIndex];
     return layer ? layer.zIndex + layer.elements.length - 1 : 0;
@@ -28,13 +29,29 @@ export function getElementIndex(indexable) {
 export function ungroupIndex(index) {
     return index.split('-')[0];
 }
+/**
+ * Insert `element` after every element that sorts before it or ties with it.
+ *
+ * The array is kept sorted by `compare`, so that predicate holds on a prefix
+ * and the position is found by bisection. The linear scan it replaces asked
+ * `compare` (which walks both elements' group chains) of every element on
+ * every insert: a paste of N elements was N² comparisons. Where an index is
+ * shared by two unrelated subtrees `compare` is not transitive and both pick
+ * a tied position, not always the same one (layer-ordered-insert.unit.spec).
+ */
 export function insertToOrderedArray(array, element) {
-    let idx = 0;
-    while (idx < array.length &&
-        [SortOrder.BEFORE, SortOrder.SAME].includes(compare(array[idx], element))) {
-        ++idx;
+    let low = 0;
+    let high = array.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (compare(array[mid], element) === SortOrder.AFTER) {
+            high = mid;
+        }
+        else {
+            low = mid + 1;
+        }
     }
-    array.splice(idx, 0, element);
+    array.splice(low, 0, element);
 }
 export function removeFromOrderedArray(array, element) {
     const idx = array.indexOf(element);
@@ -74,10 +91,40 @@ function compareLocal(a, b) {
     if (isALocal && isBLocal && a.creator && a.creator === b.creator) {
         return compareIndex(a.index, b.index);
     }
-    return {
-        a: isALocal && a.creator ? a.creator : a,
-        b: isBLocal && b.creator ? b.creator : b,
-    };
+    const left = isALocal && a.creator ? a.creator : a;
+    const right = isBLocal && b.creator ? b.creator : b;
+    // ADR 0031 §4: user layer rank first, then everything below unchanged.
+    const byLayer = compareUserLayer(left, right);
+    if (byLayer !== SortOrder.SAME)
+        return byLayer;
+    return { a: left, b: right };
+}
+/**
+ * The first step of {@link compare} (ADR 0031 §4): two models in different
+ * user layers stack by their layers' `index`; anything else is `SAME`, and
+ * today's comparator decides.
+ *
+ * The fast path is the first `return`: a surface with no `layers` answers
+ * `null` ranks after one cached read, so a document without user layers
+ * sorts with exactly the code that sorted it before layers existed. A local
+ * element without a creator has no layer and keeps today's order — above the
+ * content, as overlays always were.
+ */
+function compareUserLayer(a, b) {
+    if (a instanceof GfxLocalElementModel || b instanceof GfxLocalElementModel) {
+        return SortOrder.SAME;
+    }
+    const layers = userLayersOf(a);
+    const ranks = layers?.ranks;
+    if (!layers || !ranks)
+        return SortOrder.SAME;
+    const aLayer = layers.effectiveLayerOf(a);
+    const bLayer = layers.effectiveLayerOf(b);
+    if (aLayer === bLayer)
+        return SortOrder.SAME;
+    // A default layer with no record (the loser of a first-layer race, ADR
+    // 0031 open point 6) stacks at the bottom: `''` precedes every key.
+    return compareIndex(ranks.get(aLayer) ?? '', ranks.get(bLayer) ?? '');
 }
 /**
  * A comparator function for sorting elements in the surface.
@@ -91,15 +138,19 @@ export function compare(a, b) {
     }
     a = result.a;
     b = result.b;
-    if (isGfxGroupCompatibleModel(a) && b.groups.includes(a)) {
+    // Each `groups` read walks the group chain through `getGroup`, a scan of
+    // every container on the surface: read each side once.
+    const aGroups = a.groups;
+    const bGroups = b.groups;
+    if (isGfxGroupCompatibleModel(a) &&
+        bGroups.includes(a)) {
         return SortOrder.BEFORE;
     }
-    else if (isGfxGroupCompatibleModel(b) && a.groups.includes(b)) {
+    else if (isGfxGroupCompatibleModel(b) &&
+        aGroups.includes(b)) {
         return SortOrder.AFTER;
     }
     else {
-        const aGroups = a.groups;
-        const bGroups = b.groups;
         let i = 1;
         let aGroup = aGroups.at(-i);
         let bGroup = bGroups.at(-i);

package/dist/_pkgs/std/view/element/gfx-block-component.js

@@ -1,7 +1,7 @@
 var _a;
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { Bound } from '../../../global/gfx/index.js';
-import { computed, effect, signal } from '@preact/signals-core';
+import { computed, effect, signal, untracked } from '@preact/signals-core';
 import { nothing } from 'lit';
 import { GfxControllerIdentifier } from '../../gfx/identifiers.js';
 import { SurfaceSelection } from '../../selection/index.js';
@@ -25,7 +25,10 @@ function updateZIndex(element) {
     }
 }
 function updateBlockVisibility(view) {
-    if (view.transformState$.value === 'active') {
+    // Read inside the effect below, so a local hide or show repaints the block
+    // without a transform change (ADR 0031 §8).
+    const hiddenLocally = view.gfx.localVisibility.isHidden(view.model);
+    if (view.transformState$.value === 'active' && !hiddenLocally) {
         view.style.visibility = 'visible';
         view.style.pointerEvents = 'auto';
         view.classList.remove('block-idle');
@@ -47,12 +50,17 @@ function handleGfxConnection(instance) {
         if (id === instance.model.id && type === 'update') {
             updateTransform(instance);
             updateZIndex(instance);
+            // A move to another user layer may hide or show it (ADR 0031 §7).
+            untracked(() => updateBlockVisibility(instance));
         }
     }));
     // A reorder changes no property of this block, only the layer it sits in,
     // so the stacking has to be read back from the layer manager.
     instance.disposables.add(instance.gfx.layer.slots.layerUpdated.subscribe(() => {
         updateZIndex(instance);
+        // So may a regroup, or a change of the layer list (a layer hidden for
+        // everyone is one record write, not a write on this block).
+        untracked(() => updateBlockVisibility(instance));
     }));
     instance.disposables.add(effect(() => {
         updateBlockVisibility(instance);

package/dist/commands.js

@@ -1,5 +1,5 @@
 import { copyLinkCommands, coreCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
-import { auditCommands, exportSvgCommands, mapQualityCommands, } from './_pkgs/affine-block-surface/index.js';
+import { auditCommands, canvasGridCommands, exportSvgCommands, mapQualityCommands, selectionPaneCommands, userLayerCommands, } from './_pkgs/affine-block-surface/index.js';
 import { edgeDirectionCommands } from './_pkgs/affine-gfx-connector/index.js';
 import { shapeCommands } from './_pkgs/affine-gfx-shape/index.js';
 import { toCommandManifestEntry, } from './_pkgs/std/index.js';
@@ -54,6 +54,9 @@ export function getCommands(flags) {
         ...shapeCommands,
         ...mapQualityCommands,
         ...exportSvgCommands,
+        ...selectionPaneCommands,
+        ...canvasGridCommands,
+        ...userLayerCommands,
         ...edgeDirectionCommands,
         ...(isCapabilityEnabled(flags, 'ai-audit') ? auditCommands : []),
     ], FRAMEWORK_COMMAND_GROUPS, flags);

package/dist/translations.js

@@ -4,7 +4,7 @@ import { EMBED_WORDINGS } from './_pkgs/affine-block-embed/translations.js';
 import { EMBED_DOC_WORDINGS } from './_pkgs/affine-block-embed-doc/translations.js';
 import { FRAME_CHROME_WORDINGS, FRAME_WORDINGS, } from './_pkgs/affine-block-frame/translations.js';
 import { IMAGE_WORDINGS } from './_pkgs/affine-block-image/translations.js';
-import { EXEMPTION_FALLBACK, PROVENANCE_FALLBACK, SEVERITY_FALLBACK, SVG_SKETCH_WORDINGS, } from './_pkgs/affine-block-surface/index.js';
+import { EXEMPTION_FALLBACK, EXPORT_SVG_WORDINGS, PROVENANCE_FALLBACK, READING_FRAME_WORDINGS, SEVERITY_FALLBACK, SVG_SKETCH_WORDINGS, USER_LAYER_SEED_WORDINGS, } from './_pkgs/affine-block-surface/index.js';
 import { SURFACE_REF_CHROME_WORDINGS, SURFACE_REF_WORDINGS, } from './_pkgs/affine-block-surface-ref/translations.js';
 import { ADAPTER_PANEL_WORDINGS } from './_pkgs/affine-fragment-adapter-panel/translations.js';
 import { DOC_TITLE_WORDINGS } from './_pkgs/affine-fragment-doc-title/translations.js';
@@ -158,7 +158,11 @@ const CHROME_KEYS = [
     ['com.labre.reading.field.nature', 'Nature'],
     ['com.labre.reading.field.relations', 'Parent-child relations'],
     ['com.labre.reading.field.value-flow', 'Value flow'],
-    ['com.labre.reading.field.phase', 'Evolution phase'],
+    // `com.labre.reading.field.phase` and `com.labre.reading.phase.none` are the
+    // reading engine's DEFAULT frame wording, declared beside it in the surface
+    // package (`READING_FRAME_WORDINGS`) and walked from `PACKAGE_WORDINGS`: a
+    // profile that names no frame wording — Wardley's, a 0.43 host's — reads
+    // with them, whether or not a framework bundle is installed.
     ['com.labre.reading.field.naming', 'Naming convention'],
     ['com.labre.reading.field.record', 'Record'],
     ['com.labre.reading.field.drift', 'Drift'],
@@ -182,10 +186,7 @@ const CHROME_KEYS = [
     ['com.labre.reading.value-flow', 'Value flows up from'],
     ['com.labre.reading.value-flow.to', 'to'],
     ['com.labre.reading.phase.band', 'In the zone of punctuated equilibrium'],
-    [
-        'com.labre.reading.phase.none',
-        'Not on a framework background — no phase to read.',
-    ],
+    ['com.labre.reading.zone.unnamed', 'Unnamed'],
     [
         'com.labre.reading.naming.conforms',
         'The name follows the convention of its nature.',
@@ -303,6 +304,8 @@ const PACKAGE_WORDINGS = [
     POINTER_WORDINGS,
     ROOT_CHROME_WORDINGS,
     SVG_SKETCH_WORDINGS,
+    EXPORT_SVG_WORDINGS,
+    READING_FRAME_WORDINGS,
     STD_WORDINGS,
     ATTACHMENT_WORDINGS,
     BOOKMARK_WORDINGS,
@@ -331,6 +334,7 @@ const PACKAGE_SEED_WORDINGS = [
     SURFACE_REF_WORDINGS,
     TEMPLATE_SEED_WORDINGS,
     ROOT_SEED_WORDINGS,
+    USER_LAYER_SEED_WORDINGS,
 ];
 /**
  * Every i18n key THIS package can ask the host for, with its English fallback

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-core",
   "description": "Labre editor — the full BlockSuite-derived editor as one package.",
-  "version": "0.43.1",
+  "version": "0.45.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -873,6 +873,14 @@
     "./_pkgs/global/utils": {
       "types": "./dist/_pkgs/global/utils/index.d.ts",
       "import": "./dist/_pkgs/global/utils/index.js"
+    },
+    "./_pkgs/store": {
+      "types": "./dist/_pkgs/store/index.d.ts",
+      "import": "./dist/_pkgs/store/index.js"
+    },
+    "./_pkgs/store/index.js": {
+      "types": "./dist/_pkgs/store/index.d.ts",
+      "import": "./dist/_pkgs/store/index.js"
     }
   },
   "files": [
@@ -946,7 +954,6 @@
     "ts-pattern": "^5.1.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
-    "vitest": "^3.2.3",
     "w3c-keyname": "^2.2.8",
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.21",

package/dist/_pkgs/affine-components/icons/file-icons-rc.d.ts

@@ -1 +0,0 @@
-export declare function getAttachmentFileIconRC(filetype: string): (props: import("react").SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/_pkgs/affine-components/icons/file-icons-rc.js

@@ -1,130 +0,0 @@
-import { FileIconAepIcon, FileIconAiIcon, FileIconAviIcon, FileIconCssIcon, FileIconCsvIcon, FileIconDmgIcon, FileIconDocIcon, FileIconDocxIcon, FileIconEpsIcon, FileIconExeIcon, FileIconFigIcon, FileIconGifIcon, FileIconHtmlIcon, FileIconInddIcon, FileIconJavaIcon, FileIconJpegIcon, FileIconJsIcon, FileIconJsonIcon, FileIconMkvIcon, FileIconMp3Icon, FileIconMp4Icon, FileIconMpegIcon, FileIconNoneIcon, FileIconPdfIcon, FileIconPngIcon, FileIconPptIcon, FileIconPptxIcon, FileIconPsdIcon, FileIconRarIcon, FileIconRssIcon, FileIconSqlIcon, FileIconSvgIcon, FileIconTiffIcon, FileIconTxtIcon, FileIconWavIcon, FileIconWebpIcon, FileIconXlsIcon, FileIconXlsxIcon, FileIconXmlIcon, FileIconZipIcon, ImageIcon, } from '@blocksuite/icons/rc';
-export function getAttachmentFileIconRC(filetype) {
-    switch (filetype) {
-        case 'img':
-            return ImageIcon;
-        case 'image/jpeg':
-        case 'jpg':
-        case 'jpeg':
-            return FileIconJpegIcon;
-        case 'image/png':
-        case 'png':
-            return FileIconPngIcon;
-        case 'image/webp':
-        case 'webp':
-            return FileIconWebpIcon;
-        case 'image/tiff':
-        case 'tiff':
-            return FileIconTiffIcon;
-        case 'image/gif':
-        case 'gif':
-            return FileIconGifIcon;
-        case 'image/svg':
-        case 'svg':
-            return FileIconSvgIcon;
-        case 'image/eps':
-        case 'eps':
-            return FileIconEpsIcon;
-        case 'application/pdf':
-        case 'pdf':
-            return FileIconPdfIcon;
-        case 'application/msword':
-        case 'application/x-iwork-pages-sffpages':
-        case 'doc':
-            return FileIconDocIcon;
-        case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
-        case 'docx':
-            return FileIconDocxIcon;
-        case 'text/plain':
-        case 'txt':
-            return FileIconTxtIcon;
-        case 'csv':
-            return FileIconCsvIcon;
-        case 'application/vnd.ms-excel':
-        case 'xls':
-            return FileIconXlsIcon;
-        case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
-        case 'application/x-iwork-numbers-sffnumbers':
-        case 'xlsx':
-            return FileIconXlsxIcon;
-        case 'application/vnd.ms-powerpoint':
-        case 'application/x-iwork-keynote-sffkeynote':
-        case 'ppt':
-            return FileIconPptIcon;
-        case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
-        case 'pptx':
-            return FileIconPptxIcon;
-        case 'application/illustrator':
-        case 'fig':
-            return FileIconFigIcon;
-        case 'application/postscript':
-        case 'ai':
-            return FileIconAiIcon;
-        case 'application/vnd.adobe.photoshop':
-        case 'psd':
-            return FileIconPsdIcon;
-        case 'application/vnd.adobe.indesign':
-        case 'indd':
-            return FileIconInddIcon;
-        case 'application/vnd.adobe.afterfx':
-        case 'aep':
-            return FileIconAepIcon;
-        case 'audio/mpeg':
-        case 'audio/mp3':
-        case 'mp3':
-            return FileIconMp3Icon;
-        case 'audio/wav':
-        case 'wav':
-            return FileIconWavIcon;
-        case 'video/mpeg':
-        case 'mpeg':
-            return FileIconMpegIcon;
-        case 'video/mp4':
-        case 'mp4':
-            return FileIconMp4Icon;
-        case 'video/avi':
-        case 'avi':
-            return FileIconAviIcon;
-        case 'video/mkv':
-        case 'mkv':
-            return FileIconMkvIcon;
-        case 'text/html':
-        case 'html':
-            return FileIconHtmlIcon;
-        case 'text/css':
-        case 'css':
-            return FileIconCssIcon;
-        case 'application/rss+xml':
-        case 'rss':
-            return FileIconRssIcon;
-        case 'application/sql':
-        case 'sql':
-            return FileIconSqlIcon;
-        case 'application/javascript':
-        case 'js':
-            return FileIconJsIcon;
-        case 'application/json':
-        case 'json':
-            return FileIconJsonIcon;
-        case 'application/java':
-        case 'java':
-            return FileIconJavaIcon;
-        case 'application/xml':
-        case 'xml':
-            return FileIconXmlIcon;
-        case 'application/x-msdos-program':
-        case 'exe':
-            return FileIconExeIcon;
-        case 'application/x-apple-diskimage':
-        case 'dmg':
-            return FileIconDmgIcon;
-        case 'application/zip':
-        case 'zip':
-            return FileIconZipIcon;
-        case 'application/x-rar-compressed':
-        case 'rar':
-            return FileIconRarIcon;
-        default:
-            return FileIconNoneIcon;
-    }
-}

package/dist/_pkgs/affine-shared/test-utils/affine-template.d.ts

@@ -1,6 +0,0 @@
-import { type Block, type ExtensionType } from '../../store/index.js';
-export declare function createAffineTemplate(extensions?: ExtensionType[]): {
-    affine: (strings: TemplateStringsArray, ...values: any[]) => import("../../std/index.js").EditorHost;
-    block: (strings: TemplateStringsArray, ...values: any[]) => Block | null;
-};
-export declare const affine: (strings: TemplateStringsArray, ...values: any[]) => import("../../std/index.js").EditorHost, block: (strings: TemplateStringsArray, ...values: any[]) => Block | null;