@formicoidea/labre-core 0.46.2 → 0.47.1

package/dist/_pkgs/affine-fragment-doc-title/effects.js

@@ -1,4 +1,6 @@
 import { DocTitle } from './doc-title.js';
+import { LABRE_TITLE_BAND, TitleBand } from './title-band/title-band.js';
 export function effects() {
     customElements.define('doc-title', DocTitle);
+    customElements.define(LABRE_TITLE_BAND, TitleBand);
 }

package/dist/_pkgs/affine-fragment-doc-title/index.d.ts

@@ -1,2 +1,4 @@
 export { DocTitle } from './doc-title.js';
+export { chipEditorKind, type ChipEditorKind, type ChipTag, chipValueView, type ChipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
+export { LABRE_TITLE_BAND, TitleBand } from './title-band/title-band.js';
 export { getDocTitleByEditorHost } from './utils.js';

package/dist/_pkgs/affine-fragment-doc-title/index.js

@@ -1,2 +1,4 @@
 export { DocTitle } from './doc-title.js';
+export { chipEditorKind, chipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
+export { LABRE_TITLE_BAND, TitleBand } from './title-band/title-band.js';
 export { getDocTitleByEditorHost } from './utils.js';

package/dist/_pkgs/affine-fragment-doc-title/title-band/format.d.ts

@@ -0,0 +1,69 @@
+import type { TitleBandProperty } from '../../affine-shared/services/index.js';
+/**
+ * How a chip of the title band draws a property's value, and which editor a
+ * click opens — pure, render-free, so a host's own properties panel can show
+ * the very text a chip shows (`formatPropertyValue`, re-exported by
+ * `@labre/affine/host-panels`).
+ *
+ * The value is the JSON a data-view cell of `type` holds (ADR 0035 §9d), and
+ * the shapes below are the data-view presets' own: an option id for `select`,
+ * option ids for `multi-select`, epoch milliseconds for `date`, and a number
+ * formatted with the number preset's options, so a chip and a database cell
+ * read the same.
+ *
+ * ponytail: the band draws its chips and editors itself, per type, rather
+ * than mounting the data-view cell renderers, which need a `Cell` bound to a
+ * view and a data source the band does not have. The ceiling is a type the
+ * band does not know: it is drawn as plain text and opens no editor. The
+ * upgrade path is a hosted data source for the page's sheet once
+ * `HostedDataSourceBase` exists (ADR 0035 §7, issue B1).
+ */
+/** A select option as a data-view `select` / `multi-select` holds it. */
+export interface ChipTag {
+    id: string;
+    label: string;
+    /** A CSS colour (a `var(--…)` from the tag palette). */
+    color?: string;
+}
+export type ChipValueView = {
+    kind: 'empty';
+} | {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'checkbox';
+    checked: boolean;
+} | {
+    kind: 'tags';
+    tags: ChipTag[];
+};
+/** The editor a click on a chip opens; `none` for a type the band cannot edit. */
+export type ChipEditorKind = 'toggle' | 'select' | 'multi-select' | 'date' | 'number' | 'text' | 'none';
+/**
+ * The number preset's formats (`data-view/…/number/utils/formatter.ts`),
+ * restated rather than imported: the preset formats with
+ * `navigator.language`, which ignores the host's locale and throws on a tag
+ * `Intl` refuses (`en-US@posix` in a headless Chromium), and a chip must
+ * neither. `title-band-number-parity.unit.spec.ts` (`affine/all`) holds the
+ * two tables together.
+ */
+export declare const CHIP_NUMBER_FORMATS: Readonly<Record<string, Intl.NumberFormatOptions>>;
+/** The options of a select-like property, whatever its `data` holds. */
+export declare function chipOptions(property: TitleBandProperty): ChipTag[];
+/** Nullish, a blank string or an empty list. `false` is a value, not empty. */
+export declare function isPropertyValueEmpty(property: TitleBandProperty): boolean;
+/** What a chip draws for this property's value. Never throws. */
+export declare function chipValueView(property: TitleBandProperty, locale: string): ChipValueView;
+/**
+ * The value as one line of text, as a chip reads it: option labels joined by
+ * a comma, an empty value as `''`. A checkbox has no text either: it is a
+ * mark, not a word, so a host draws its own from `property.value`.
+ */
+export declare function formatPropertyValue(property: TitleBandProperty, locale?: string): string;
+/**
+ * A number typed in a chip's editor: blanks dropped, a decimal comma read as
+ * a point. `NaN` for anything else, which the band writes as `null`.
+ */
+export declare function parseChipNumber(text: string): number;
+/** The editor a click on this property's chip opens. */
+export declare function chipEditorKind(property: TitleBandProperty): ChipEditorKind;

package/dist/_pkgs/affine-fragment-doc-title/title-band/format.js

@@ -0,0 +1,182 @@
+const TEXT_TYPES = new Set([
+    'text',
+    'rich-text',
+    'title',
+    'url',
+    'link',
+    'email',
+    'phone',
+]);
+const DATE_TYPES = new Set(['date', 'created-time', 'modified-time']);
+const currency = (code) => ({
+    style: 'currency',
+    currency: code,
+    currencyDisplay: 'symbol',
+});
+/**
+ * The number preset's formats (`data-view/…/number/utils/formatter.ts`),
+ * restated rather than imported: the preset formats with
+ * `navigator.language`, which ignores the host's locale and throws on a tag
+ * `Intl` refuses (`en-US@posix` in a headless Chromium), and a chip must
+ * neither. `title-band-number-parity.unit.spec.ts` (`affine/all`) holds the
+ * two tables together.
+ */
+export const CHIP_NUMBER_FORMATS = {
+    number: { style: 'decimal', useGrouping: false },
+    numberWithCommas: { style: 'decimal', useGrouping: true },
+    percent: { style: 'percent', useGrouping: false },
+    currencyINR: currency('INR'),
+    currencyYen: currency('JPY'),
+    currencyCNY: currency('CNY'),
+    currencyUSD: currency('USD'),
+    currencyEUR: currency('EUR'),
+    currencyGBP: currency('GBP'),
+};
+/** `Intl.NumberFormat`, or the bare number when `Intl` refuses the locale. */
+function numberText(value, locale, options = {}) {
+    try {
+        return new Intl.NumberFormat(locale, options).format(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** The options of a select-like property, whatever its `data` holds. */
+export function chipOptions(property) {
+    const options = property.data.options;
+    if (!Array.isArray(options))
+        return [];
+    const tags = [];
+    for (const option of options) {
+        if (option == null || typeof option !== 'object')
+            continue;
+        const { id, value, color } = option;
+        if (typeof id !== 'string')
+            continue;
+        tags.push({
+            id,
+            label: typeof value === 'string' ? value : '',
+            color: typeof color === 'string' ? color : undefined,
+        });
+    }
+    return tags;
+}
+/** Nullish, a blank string or an empty list. `false` is a value, not empty. */
+export function isPropertyValueEmpty(property) {
+    const { value } = property;
+    if (value == null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'number')
+        return Number.isNaN(value);
+    return false;
+}
+function formatDate(value, locale) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return '';
+    try {
+        return new Intl.DateTimeFormat(locale, { dateStyle: 'medium' }).format(date);
+    }
+    catch {
+        return date.toISOString().slice(0, 10);
+    }
+}
+function formatNumberValue(property, value, locale) {
+    const { format, decimal } = property.data;
+    const options = {
+        ...(typeof format === 'string' && Object.hasOwn(CHIP_NUMBER_FORMATS, format)
+            ? CHIP_NUMBER_FORMATS[format]
+            : CHIP_NUMBER_FORMATS.number),
+    };
+    if (typeof decimal === 'number') {
+        options.minimumFractionDigits = decimal;
+        options.maximumFractionDigits = decimal;
+    }
+    return numberText(value, locale, options);
+}
+/** What a chip draws for this property's value. Never throws. */
+export function chipValueView(property, locale) {
+    const { type, value } = property;
+    if (type === 'checkbox')
+        return { kind: 'checkbox', checked: value === true };
+    if (isPropertyValueEmpty(property))
+        return { kind: 'empty' };
+    if (type === 'select' || type === 'multi-select') {
+        const ids = Array.isArray(value) ? value : [value];
+        const options = chipOptions(property);
+        const tags = ids.flatMap(id => options.filter(option => option.id === id));
+        return tags.length > 0 ? { kind: 'tags', tags } : { kind: 'empty' };
+    }
+    if (DATE_TYPES.has(type) && typeof value === 'number') {
+        const text = formatDate(value, locale);
+        return text ? { kind: 'text', text } : { kind: 'empty' };
+    }
+    if (type === 'number' && typeof value === 'number') {
+        return { kind: 'text', text: formatNumberValue(property, value, locale) };
+    }
+    if (type === 'progress' && typeof value === 'number') {
+        return {
+            kind: 'text',
+            text: numberText(value / 100, locale, { style: 'percent' }),
+        };
+    }
+    if (typeof value === 'string')
+        return { kind: 'text', text: value };
+    if (typeof value === 'number') {
+        return { kind: 'text', text: numberText(value, locale) };
+    }
+    if (Array.isArray(value)) {
+        const text = value.filter(item => typeof item === 'string').join(', ');
+        return text ? { kind: 'text', text } : { kind: 'empty' };
+    }
+    return { kind: 'empty' };
+}
+/**
+ * The value as one line of text, as a chip reads it: option labels joined by
+ * a comma, an empty value as `''`. A checkbox has no text either: it is a
+ * mark, not a word, so a host draws its own from `property.value`.
+ */
+export function formatPropertyValue(property, locale = 'en-US') {
+    const view = chipValueView(property, locale);
+    switch (view.kind) {
+        case 'text':
+            return view.text;
+        case 'tags':
+            return view.tags.map(tag => tag.label).join(', ');
+        default:
+            return '';
+    }
+}
+/**
+ * A number typed in a chip's editor: blanks dropped, a decimal comma read as
+ * a point. `NaN` for anything else, which the band writes as `null`.
+ */
+export function parseChipNumber(text) {
+    const compact = text.replace(/\s/g, '');
+    if (compact === '')
+        return NaN;
+    return Number(compact.replace(',', '.'));
+}
+/** The editor a click on this property's chip opens. */
+export function chipEditorKind(property) {
+    if (property.readonly)
+        return 'none';
+    const { type } = property;
+    if (type === 'checkbox')
+        return 'toggle';
+    if (type === 'select')
+        return 'select';
+    if (type === 'multi-select')
+        return 'multi-select';
+    if (type === 'date')
+        return 'date';
+    if (type === 'number' || type === 'progress')
+        return 'number';
+    if (TEXT_TYPES.has(type))
+        return 'text';
+    return 'none';
+}

package/dist/_pkgs/affine-fragment-doc-title/title-band/title-band.d.ts

@@ -0,0 +1,62 @@
+import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
+import { nothing, type TemplateResult } from 'lit';
+export declare const LABRE_TITLE_BAND = "labre-title-band";
+declare const TitleBand_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * The band of property chips under the page title and at the head of the
+ * page's note on the canvas (ADR 0035 §11, REQ-PR-1 and PR-7).
+ *
+ * One component for both views: `<doc-title>` mounts it under the title
+ * (`surface="page"`), `edgeless-page-block-title` at the head of the page's
+ * note (`surface="canvas"`). On the canvas it sits inside the note's own DOM,
+ * so it follows the zoom like the rest of the note (REQ-PR-7), and it is
+ * interactive when the note is, i.e. once the note is being edited.
+ *
+ * Fed by `TitleBandProvider` alone (§9d): no provider, nothing at all. The
+ * chips are the sheet's visible properties in the host's order, an empty one
+ * included (REQ-PR-1); a click opens the editor of the property's data-view
+ * type and hands the value back through `set`, showing the chip as pending
+ * until the host settles it. The band never writes to the document and never
+ * applies a value. The "+" is drawn when the host passes `add`; the panel
+ * button when a `PropertiesPanelProvider` is registered; the "Not shown in
+ * this document" row only on the canvas (the page view's row is the host's).
+ */
+export declare class TitleBand extends TitleBand_base {
+    static styles: import("lit").CSSResult;
+    private _sources;
+    /** The editor menu open now, put away with the band. */
+    private _menu;
+    private _pop;
+    /** Collapse state when the host does not remember one. */
+    private readonly _localCollapsed$;
+    /** Property ids whose `set` has not settled yet. */
+    private readonly _pending$;
+    /** Read inside `render` it subscribes, through `SignalWatcher`. */
+    private get _readonly();
+    private get _locale();
+    private _t;
+    private _getSources;
+    private _isCollapsed;
+    private _setCollapsed;
+    private _write;
+    private readonly _onChip;
+    private _tagLabel;
+    private _clearItem;
+    private _popSelect;
+    private _popMultiSelect;
+    private _popDate;
+    private _popInput;
+    private readonly _openPanel;
+    private _renderValue;
+    private _renderChip;
+    private _renderTools;
+    private _renderSheet;
+    private _renderNotShown;
+    connectedCallback(): void;
+    render(): TemplateResult<1> | typeof nothing;
+    accessor std: BlockStdScope | null;
+    accessor docId: string;
+    /** Where the band is drawn; only the canvas draws the "Not shown" row. */
+    accessor surface: 'page' | 'canvas';
+}
+export {};