@formicoidea/labre-core 0.49.0 → 0.51.0

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

@@ -32,3 +32,26 @@ export declare const parseMatter: (contents: string) => {
     metadata: Record<string, FrontmatterValue>;
 } | null;
 export declare function download(blob: Blob, name: string): void;
+/**
+ * A page exported to a file, before anything is done with it: the bytes and
+ * the name a download would give them. What `exportDoc` downloads, and what
+ * the `page.export.*` view actions hand to the host instead.
+ */
+export interface DocExportFile {
+    blob: Blob;
+    /** Sanitised, extension included: `Order to cash.md` or `Order to cash.zip`. */
+    filename: string;
+}
+/**
+ * Pack an adapter's output: the document alone when it references no asset,
+ * else a zip holding it as `index.<ext>` beside an `assets/` folder — the
+ * relative paths the Markdown and HTML adapters write for images point there.
+ */
+export declare function packDocExport(result: {
+    file: string;
+    assetsIds: string[];
+}, assets: Map<string, Blob>, { name, extension, mime }: {
+    name: string;
+    extension: string;
+    mime: string;
+}): Promise<DocExportFile>;

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

@@ -214,3 +214,17 @@ export function download(blob, name) {
     element.remove();
     URL.revokeObjectURL(fileURL);
 }
+/**
+ * Pack an adapter's output: the document alone when it references no asset,
+ * else a zip holding it as `index.<ext>` beside an `assets/` folder — the
+ * relative paths the Markdown and HTML adapters write for images point there.
+ */
+export async function packDocExport(result, assets, { name, extension, mime }) {
+    const content = new Blob([result.file], { type: mime });
+    if (result.assetsIds.length === 0) {
+        return { blob: content, filename: `${name}${extension}` };
+    }
+    const zip = await createAssetsArchive(assets, result.assetsIds);
+    await zip.file(`index${extension}`, content);
+    return { blob: await zip.generate(), filename: `${name}.zip` };
+}

package/dist/_pkgs/data-view/core/common/properties.d.ts

@@ -2,18 +2,46 @@ import { type PopupTarget } from '../../../affine-components/context-menu/index.
 import { ShadowlessElement } from '../../../std/index.js';
 import type { Property } from '../view-manager/property.js';
 import type { SingleView } from '../view-manager/single-view.js';
+import { type Wording } from '../utils/wording.js';
 declare const DataViewPropertiesSettingView_base: typeof ShadowlessElement & import("../../../global/utils/types.js").Constructor<import("../../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * The properties of a view, as the view options' "Properties" and the
+ * database's side panel (`affine-database-properties-panel`) both draw
+ * them: one row per property of the source, in this view's order.
+ *
+ * - The eye hides or shows the property in this view only, the drag bar
+ *   reorders it in this view only.
+ * - A click on the row opens the property's own menu, the one the table's
+ *   column header opens (`propertyMenuItems`): rename, type, duplicate
+ *   and delete write the data source, so every view sees them. Kanban,
+ *   gallery and list have no column header; this row is their way in.
+ * - "New property" adds one at the end of the source through the type
+ *   picker of the virtual table header and the record detail, then opens
+ *   its menu for the rename.
+ *
+ * Read-only (the view or its source), a click opens nothing and "New
+ * property" is not drawn, as the header does. The title follows the menu's
+ * own rules (no type change, no hide, no delete).
+ */
 export declare class DataViewPropertiesSettingView extends DataViewPropertiesSettingView_base {
     static styles: import("lit").CSSResult;
     accessor view: SingleView;
     items$: import("@preact/signals-core").ReadonlySignal<string[]>;
+    private readonly _openMenu;
+    private readonly _newProperty;
     renderProperty: (property: Property) => import("lit-html").TemplateResult<1>;
+    private _renderNewProperty;
     sortContext: import("../utils/wc-dnd/sort/sort-context.js").SortContext;
     private itemsGroup;
     connectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
     accessor groupContainer: HTMLElement;
     accessor onBack: (() => void) | undefined;
+    /**
+     * The list draws inside a popup or a host's panel, outside the editor's
+     * context: its opener resolves the words (`wordingOf(std)`).
+     */
+    accessor wording: Wording;
 }
 declare global {
     interface HTMLElementTagNameMap {
@@ -24,5 +52,6 @@ export declare const popPropertiesSetting: (target: PopupTarget, props: {
     view: SingleView;
     onClose?: () => void;
     onBack?: () => void;
+    wording?: Wording;
 }) => void;
 export {};

package/dist/_pkgs/data-view/core/common/properties.js

@@ -32,20 +32,42 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { menu, popMenu, } from '../../../affine-components/context-menu/index.js';
+import { menu, popMenu, popupTargetFromElement, } from '../../../affine-components/context-menu/index.js';
 import { SignalWatcher, WithDisposable } from '../../../global/lit/index.js';
-import { InvisibleIcon, ViewIcon } from '@blocksuite/icons/lit';
+import { InvisibleIcon, PlusIcon, ViewIcon } from '@blocksuite/icons/lit';
 import { ShadowlessElement } from '../../../std/index.js';
 import { computed } from '@preact/signals-core';
 import { cssVarV2 } from '@toeverything/theme/v2';
-import { css, html, unsafeCSS } from 'lit';
+import { css, html, nothing, unsafeCSS } from 'lit';
 import { property, query } from 'lit/decorators.js';
 import { classMap } from 'lit/directives/class-map.js';
 import { repeat } from 'lit/directives/repeat.js';
+import { DATA_VIEW_NEW_PROPERTY, DATA_VIEW_PROPERTIES, DATA_VIEW_PROPERTY_TYPE, } from '../../translations.js';
 import { dragHandler } from '../utils/wc-dnd/dnd-context.js';
 import { defaultActivators } from '../utils/wc-dnd/sensors/index.js';
 import { createSortContext, sortable, } from '../utils/wc-dnd/sort/sort-context.js';
 import { verticalListSortingStrategy } from '../utils/wc-dnd/sort/strategies/index.js';
+import { englishWording } from '../utils/wording.js';
+import { popNewPropertyMenu, popPropertyMenu } from './property-menu.js';
+/**
+ * The properties of a view, as the view options' "Properties" and the
+ * database's side panel (`affine-database-properties-panel`) both draw
+ * them: one row per property of the source, in this view's order.
+ *
+ * - The eye hides or shows the property in this view only, the drag bar
+ *   reorders it in this view only.
+ * - A click on the row opens the property's own menu, the one the table's
+ *   column header opens (`propertyMenuItems`): rename, type, duplicate
+ *   and delete write the data source, so every view sees them. Kanban,
+ *   gallery and list have no column header; this row is their way in.
+ * - "New property" adds one at the end of the source through the type
+ *   picker of the virtual table header and the record detail, then opens
+ *   its menu for the rename.
+ *
+ * Read-only (the view or its source), a click opens nothing and "New
+ * property" is not drawn, as the header does. The title follows the menu's
+ * own rules (no type change, no hide, no delete).
+ */
 let DataViewPropertiesSettingView = (() => {
     let _classSuper = SignalWatcher(WithDisposable(ShadowlessElement));
     let _view_decorators;
@@ -57,15 +79,20 @@ let DataViewPropertiesSettingView = (() => {
     let _onBack_decorators;
     let _onBack_initializers = [];
     let _onBack_extraInitializers = [];
+    let _wording_decorators;
+    let _wording_initializers = [];
+    let _wording_extraInitializers = [];
     return class DataViewPropertiesSettingView extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _view_decorators = [property({ attribute: false })];
             _groupContainer_decorators = [query('.properties-group')];
             _onBack_decorators = [property({ attribute: false })];
+            _wording_decorators = [property({ attribute: false })];
             __esDecorate(this, null, _view_decorators, { kind: "accessor", name: "view", static: false, private: false, access: { has: obj => "view" in obj, get: obj => obj.view, set: (obj, value) => { obj.view = value; } }, metadata: _metadata }, _view_initializers, _view_extraInitializers);
             __esDecorate(this, null, _groupContainer_decorators, { kind: "accessor", name: "groupContainer", static: false, private: false, access: { has: obj => "groupContainer" in obj, get: obj => obj.groupContainer, set: (obj, value) => { obj.groupContainer = value; } }, metadata: _metadata }, _groupContainer_initializers, _groupContainer_extraInitializers);
             __esDecorate(this, null, _onBack_decorators, { kind: "accessor", name: "onBack", static: false, private: false, access: { has: obj => "onBack" in obj, get: obj => obj.onBack, set: (obj, value) => { obj.onBack = value; } }, metadata: _metadata }, _onBack_initializers, _onBack_extraInitializers);
+            __esDecorate(this, null, _wording_decorators, { kind: "accessor", name: "wording", static: false, private: false, access: { has: obj => "wording" in obj, get: obj => obj.wording, set: (obj, value) => { obj.wording = value; } }, metadata: _metadata }, _wording_initializers, _wording_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = css `
@@ -170,10 +197,36 @@ let DataViewPropertiesSettingView = (() => {
       line-height: 22px;
       flex: 1;
     }
+
+    .property-item:hover {
+      background-color: var(--affine-hover-color);
+    }
+
+    .property-item-new {
+      color: var(--affine-text-secondary-color);
+    }
+
+    .property-item-new .property-item-icon {
+      padding-left: 12px;
+    }
   `; }
         #view_accessor_storage;
         get view() { return this.#view_accessor_storage; }
         set view(value) { this.#view_accessor_storage = value; }
+        _renderNewProperty() {
+            if (this.view.readonly$.value)
+                return nothing;
+            return html `<div
+      class="property-item property-item-new"
+      data-testid="data-view-properties-new"
+      @click="${this._newProperty}"
+    >
+      <div class="property-item-icon">${PlusIcon()}</div>
+      <div class="property-item-name">
+        ${this.wording(DATA_VIEW_NEW_PROPERTY)}
+      </div>
+    </div>`;
+        }
         itemsGroup() {
             return this.view.propertiesRaw$.value;
         }
@@ -189,6 +242,7 @@ let DataViewPropertiesSettingView = (() => {
       <div class="properties-group">
         ${repeat(items, v => v.id, this.renderProperty)}
       </div>
+      ${this._renderNewProperty()}
     `;
         }
         #groupContainer_accessor_storage;
@@ -197,15 +251,49 @@ let DataViewPropertiesSettingView = (() => {
         #onBack_accessor_storage;
         get onBack() { return this.#onBack_accessor_storage; }
         set onBack(value) { this.#onBack_accessor_storage = value; }
+        #wording_accessor_storage;
+        /**
+         * The list draws inside a popup or a host's panel, outside the editor's
+         * context: its opener resolves the words (`wordingOf(std)`).
+         */
+        get wording() { return this.#wording_accessor_storage; }
+        set wording(value) { this.#wording_accessor_storage = value; }
         constructor() {
             super(...arguments);
             this.#view_accessor_storage = __runInitializers(this, _view_initializers, void 0);
             this.items$ = (__runInitializers(this, _view_extraInitializers), computed(() => {
                 return this.view.propertiesRaw$.value.map(property => property.id);
             }));
+            this._openMenu = (property, row) => {
+                if (this.view.readonly$.value)
+                    return;
+                popPropertyMenu(popupTargetFromElement(row), property, {
+                    wording: this.wording,
+                });
+            };
+            this._newProperty = (event) => {
+                if (this.view.readonly$.value)
+                    return;
+                const button = event.currentTarget;
+                popNewPropertyMenu(popupTargetFromElement(button), this.view, {
+                    title: this.wording(DATA_VIEW_PROPERTY_TYPE),
+                    onAdd: id => {
+                        this.updateComplete
+                            .then(() => {
+                            const row = this.querySelector(`.property-item[data-property-id="${CSS.escape(id)}"]`);
+                            row?.scrollIntoView({ block: 'nearest' });
+                            this._openMenu(this.view.propertyGetOrCreate(id), row ?? button);
+                        })
+                            .catch(console.error);
+                    },
+                });
+            };
             this.renderProperty = (property) => {
                 const icon = property.hide$.value ? InvisibleIcon() : ViewIcon();
-                const changeVisible = () => {
+                // The eye and the drag bar keep their own gesture: the row's click is
+                // the property's menu, so they stop it.
+                const changeVisible = (event) => {
+                    event.stopPropagation();
                     if (property.hideCanSet) {
                         property.hideSet(!property.hide$.value);
                     }
@@ -218,11 +306,23 @@ let DataViewPropertiesSettingView = (() => {
       ${dragHandler(property.id)}
       ${sortable(property.id)}
       class="property-item"
+      data-testid="data-view-property-item"
+      data-property-id="${property.id}"
+      @click="${(event) => this._openMenu(property, event.currentTarget)}"
     >
-      <div class="property-item-drag-bar"></div>
+      <div
+        class="property-item-drag-bar"
+        @click="${(event) => event.stopPropagation()}"
+      ></div>
       <uni-lit class="property-item-icon" .uni="${property.icon}"></uni-lit>
       <div class="property-item-name">${property.name$.value}</div>
-      <div class="${classList}" @click="${changeVisible}">${icon}</div>
+      <div
+        class="${classList}"
+        data-testid="data-view-property-visibility"
+        @click="${changeVisible}"
+      >
+        ${icon}
+      </div>
     </div>`;
             };
             this.sortContext = createSortContext({
@@ -259,7 +359,8 @@ let DataViewPropertiesSettingView = (() => {
             });
             this.#groupContainer_accessor_storage = __runInitializers(this, _groupContainer_initializers, void 0);
             this.#onBack_accessor_storage = (__runInitializers(this, _groupContainer_extraInitializers), __runInitializers(this, _onBack_initializers, undefined));
-            __runInitializers(this, _onBack_extraInitializers);
+            this.#wording_accessor_storage = (__runInitializers(this, _onBack_extraInitializers), __runInitializers(this, _wording_initializers, englishWording));
+            __runInitializers(this, _wording_extraInitializers);
         }
     };
 })();
@@ -268,7 +369,7 @@ export const popPropertiesSetting = (target, props) => {
     popMenu(target, {
         options: {
             title: {
-                text: 'Properties',
+                text: (props.wording ?? englishWording)(DATA_VIEW_PROPERTIES),
                 onBack: props.onBack,
                 postfix: () => {
                     const items = props.view.propertiesRaw$.value;
@@ -293,6 +394,7 @@ export const popPropertiesSetting = (target, props) => {
                     items: [
                         () => html ` <data-view-properties-setting
                 .view="${props.view}"
+                .wording="${props.wording ?? englishWording}"
               ></data-view-properties-setting>`,
                     ],
                 }),

package/dist/_pkgs/data-view/core/common/property-menu.d.ts

@@ -1,3 +1,46 @@
+import { type MenuConfig, type PopupTarget } from '../../../affine-components/context-menu/index.js';
+import { type Wording } from '../utils/wording.js';
 import type { Property } from '../view-manager/property.js';
+import type { SingleView } from '../view-manager/single-view.js';
 export declare const inputConfig: (property: Property) => (menu: import("../../../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
-export declare const typeConfig: (property: Property) => (menu: import("../../../affine-components/context-menu/menu.js").Menu, index: number) => import("lit-html").TemplateResult | undefined;
+export declare const typeConfig: (property: Property, wording?: Wording) => (menu: import("../../../affine-components/context-menu/menu.js").Menu, index: number) => import("lit-html").TemplateResult | undefined;
+/** What a property menu's opener adds around the shared entries. */
+export type PropertyMenuSlots = {
+    /** Right after the type (the table's "Number Format"). */
+    afterType?: MenuConfig[];
+    /** Between "Hide In View" and the duplicate/delete group. */
+    beforeOperations?: MenuConfig[];
+    /** The opener's words (`wordingOf(std)`); English without it. */
+    wording?: Wording;
+};
+/**
+ * The edit menu of one property: the very menu the table's column header
+ * opens, rename and type first, duplicate and delete last. Every opener
+ * reads it from here (the table header with its own filter, sort, insert
+ * and move entries in `slots`; the properties list of every view as is), so
+ * the title keeps the header's rules wherever it is edited: no type change,
+ * no hide, no delete, because `typeCanSet`, `hideCanSet` and `canDelete` say
+ * so. Rename, type, duplicate and delete write the data source, every view
+ * at once; "Hide In View" writes this view only.
+ *
+ * The caller checks `readonly$` before opening it, as the header does.
+ *
+ * ponytail: "Number Format" stays a table slot (its bar is a table/pc
+ * element, behind `enable_number_formatting`, off in Labre), so the
+ * properties list does not offer it. Move the bar to core and the entry into
+ * this list when the flag ships. The virtual and mobile table headers still
+ * spell their own copy of these entries; point them here in a dedicated pass.
+ */
+export declare const propertyMenuItems: (property: Property, slots?: PropertyMenuSlots) => MenuConfig[];
+export declare const popPropertyMenu: (target: PopupTarget, property: Property, slots?: PropertyMenuSlots) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;
+/**
+ * The type picker of a new property, as the virtual table header's "+" and
+ * the record detail's "Add property" draw it: one entry per type the source
+ * offers, named after the type. The property is added at the end of the
+ * source (every view), under the type's own name, and `onAdd` gets its id
+ * so the opener can open its menu for the rename.
+ */
+export declare const popNewPropertyMenu: (target: PopupTarget, view: SingleView, options: {
+    title: string;
+    onAdd: (id: string) => void;
+}) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;

package/dist/_pkgs/data-view/core/common/property-menu.js

@@ -1,6 +1,10 @@
-import { menu } from '../../../affine-components/context-menu/index.js';
+import { menu, popMenu, } from '../../../affine-components/context-menu/index.js';
+import { TOOLBAR_DELETE, TOOLBAR_DUPLICATE, } from '../../../affine-shared/services/index.js';
+import { DeleteIcon, DuplicateIcon, ViewIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit/static-html.js';
+import { DATA_VIEW_PROPERTY_HIDE_IN_VIEW, DATA_VIEW_PROPERTY_TYPE, } from '../../translations.js';
 import { renderUniLit } from '../utils/uni-component/index.js';
+import { englishWording } from '../utils/wording.js';
 export const inputConfig = (property) => {
     return menu.input({
         prefix: html `
@@ -17,7 +21,7 @@ export const inputConfig = (property) => {
         },
     });
 };
-export const typeConfig = (property) => {
+export const typeConfig = (property, wording = englishWording) => {
     return menu.group({
         items: [
             menu.subMenu({
@@ -32,7 +36,7 @@ export const typeConfig = (property) => {
         </div>`,
                 options: {
                     title: {
-                        text: 'Property type',
+                        text: wording(DATA_VIEW_PROPERTY_TYPE),
                     },
                     items: [
                         menu.group({
@@ -56,3 +60,96 @@ export const typeConfig = (property) => {
         ],
     });
 };
+/**
+ * The edit menu of one property: the very menu the table's column header
+ * opens, rename and type first, duplicate and delete last. Every opener
+ * reads it from here (the table header with its own filter, sort, insert
+ * and move entries in `slots`; the properties list of every view as is), so
+ * the title keeps the header's rules wherever it is edited: no type change,
+ * no hide, no delete, because `typeCanSet`, `hideCanSet` and `canDelete` say
+ * so. Rename, type, duplicate and delete write the data source, every view
+ * at once; "Hide In View" writes this view only.
+ *
+ * The caller checks `readonly$` before opening it, as the header does.
+ *
+ * ponytail: "Number Format" stays a table slot (its bar is a table/pc
+ * element, behind `enable_number_formatting`, off in Labre), so the
+ * properties list does not offer it. Move the bar to core and the entry into
+ * this list when the flag ships. The virtual and mobile table headers still
+ * spell their own copy of these entries; point them here in a dedicated pass.
+ */
+export const propertyMenuItems = (property, slots = {}) => {
+    const wording = slots.wording ?? englishWording;
+    return [
+        inputConfig(property),
+        typeConfig(property, wording),
+        ...(slots.afterType ?? []),
+        menu.group({
+            items: [
+                menu.action({
+                    name: wording(DATA_VIEW_PROPERTY_HIDE_IN_VIEW),
+                    prefix: ViewIcon(),
+                    hide: () => !property.hideCanSet,
+                    select: () => {
+                        property.hideSet(true);
+                    },
+                }),
+            ],
+        }),
+        ...(slots.beforeOperations ?? []),
+        menu.group({
+            items: [
+                menu.action({
+                    name: wording(TOOLBAR_DUPLICATE),
+                    prefix: DuplicateIcon(),
+                    hide: () => !property.canDuplicate,
+                    select: () => {
+                        property.duplicate?.();
+                    },
+                }),
+                menu.action({
+                    name: wording(TOOLBAR_DELETE),
+                    prefix: DeleteIcon(),
+                    hide: () => !property.canDelete,
+                    select: () => {
+                        property.delete?.();
+                    },
+                    class: {
+                        'delete-item': true,
+                    },
+                }),
+            ],
+        }),
+    ];
+};
+export const popPropertyMenu = (target, property, slots) => popMenu(target, {
+    options: { items: propertyMenuItems(property, slots) },
+});
+/**
+ * The type picker of a new property, as the virtual table header's "+" and
+ * the record detail's "Add property" draw it: one entry per type the source
+ * offers, named after the type. The property is added at the end of the
+ * source (every view), under the type's own name, and `onAdd` gets its id
+ * so the opener can open its menu for the rename.
+ */
+export const popNewPropertyMenu = (target, view, options) => popMenu(target, {
+    options: {
+        title: { text: options.title },
+        items: [
+            menu.group({
+                items: view.propertyMetas$.value.map(meta => menu.action({
+                    name: meta.config.name,
+                    prefix: renderUniLit(meta.renderer.icon),
+                    select: () => {
+                        const id = view.propertyAdd('end', {
+                            type: meta.type,
+                            name: meta.config.name,
+                        });
+                        if (id)
+                            options.onAdd(id);
+                    },
+                })),
+            }),
+        ],
+    },
+});

package/dist/_pkgs/data-view/core/component/tags/color-carousel.d.ts

@@ -0,0 +1,41 @@
+import { type PaletteCarouselDirection, type PaletteGroup } from '../../../../affine-components/color-picker/index.js';
+import type { BlockStdScope } from '../../../../std/index.js';
+import { LitElement, nothing } from 'lit';
+/**
+ * The database colour grid when it has more than one page (ADR 0036
+ * amendment of 2026-10-14, "framework pages"): the canvas carousel's own
+ * header, list and page (`renderPaletteCarousel`, `paletteCarouselPage`,
+ * ADR 0027) above the same `<edgeless-color-panel>` a single page shows.
+ *
+ * An element, not a render helper as on the canvas: a menu entry is a
+ * function the menu calls again on every render, so the page on screen and
+ * the open list need a home that outlives one call. Nothing here is
+ * persisted; a pick bubbles as the panel's own `select` event.
+ */
+export declare class DataViewColorCarousel extends LitElement {
+    static styles: import("lit").CSSResult[];
+    /** The page on screen: the one the user paged to, else the current colour's. */
+    get pageIndex(): number;
+    private _refocusHeader;
+    private readonly _page;
+    /**
+     * Closing the list removes the button that had the focus; the keyboard
+     * path goes on from the header, one Tab away from the new page's grid.
+     */
+    private readonly _toggle;
+    updated(): void;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    accessor current: string | null;
+    accessor direction: PaletteCarouselDirection;
+    /** The pages, the ten chip colours first (`selectOptionColorPages`). */
+    accessor groups: readonly PaletteGroup[];
+    accessor listOpen: boolean;
+    accessor pickedIndex: number | undefined;
+    /** Only for the header's own wording ("Choose a palette"). */
+    accessor std: BlockStdScope | undefined;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'dv-color-carousel': DataViewColorCarousel;
+    }
+}