@formicoidea/labre-core 0.60.0 → 1.0.0

package/dist/_pkgs/affine-database-block/service/initial-view.d.ts

@@ -0,0 +1,33 @@
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * Which `affine:database` block asks for the view it opens on. Only widens:
+ * a new field is optional.
+ */
+export interface DatabaseInitialViewRequest {
+    blockId: string;
+}
+/**
+ * The view a database opens on, chosen by the host (labre: a base's page
+ * opened from one of its views in the sidebar, `/base/:id?view=…`). Asked
+ * once, when the block builds its data source. An id the block does not
+ * have, or `undefined`, falls back to the view this tab last showed for the
+ * block (`currentViewStorage`), then to the first view.
+ *
+ * Nothing is written: the current view is a local signal of the view
+ * manager, never a stored prop, so opening on a view leaves the document
+ * untouched.
+ */
+export interface DatabaseInitialViewService {
+    initialView(request: DatabaseInitialViewRequest): string | undefined;
+}
+export declare const DatabaseInitialViewProvider: import("../../global/di/types.js").ServiceIdentifier<DatabaseInitialViewService> & (<U extends DatabaseInitialViewService = DatabaseInitialViewService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the view a database opens on.
+ *
+ * Absent or `null`, a database opens on the view this tab last showed for
+ * it, else its first view, as in 0.59.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export declare function DatabaseInitialViewExtension(service: DatabaseInitialViewService | null): ExtensionType;

package/dist/_pkgs/affine-database-block/service/initial-view.js

@@ -0,0 +1,20 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const DatabaseInitialViewProvider = createIdentifier('LabreDatabaseInitialView');
+/**
+ * Host seam: the view a database opens on.
+ *
+ * Absent or `null`, a database opens on the view this tab last showed for
+ * it, else its first view, as in 0.59.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export function DatabaseInitialViewExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through on purpose: `getOptional` then reports no host
+            // choice and the block keeps its own.
+            di.override(DatabaseInitialViewProvider, () => service);
+        },
+    };
+}

package/dist/_pkgs/affine-database-block/standalone-layout.d.ts

@@ -0,0 +1,22 @@
+/** What the measure reads of the database block element. */
+export type StandaloneCandidate = HTMLElement & {
+    readonly rootComponent: Element | null;
+};
+/**
+ * Whether a database block is drawn as the page itself rather than inside a
+ * text (ADR 0035 amendment of 2026-10-28): a full page whose heading is the
+ * database's name and whose only scroller holds both.
+ *
+ * Two facts measured in the DOM, never stored and never read from a prop:
+ * - the block's parent block element is the root component: inline, a
+ *   database always sits in a note; the full page's root
+ *   (`affine-database-page-root`) renders the block directly;
+ * - its scroll container holds a `<doc-title>` whose `body-block-id` names
+ *   this block (`<doc-title .bodyBlockId>`, reflected): the page heading the
+ *   host composed above it. Without one, the page renders the database as
+ *   inline, its own title row shown.
+ *
+ * The parent test comes first: it fails at once for every inline database,
+ * so a text page never pays for the scroll-container walk.
+ */
+export declare function isStandaloneDatabase(element: StandaloneCandidate, blockId: string): boolean;

package/dist/_pkgs/affine-database-block/standalone-layout.js

@@ -0,0 +1,27 @@
+import { getScrollContainer } from '../affine-shared/utils/index.js';
+/**
+ * Whether a database block is drawn as the page itself rather than inside a
+ * text (ADR 0035 amendment of 2026-10-28): a full page whose heading is the
+ * database's name and whose only scroller holds both.
+ *
+ * Two facts measured in the DOM, never stored and never read from a prop:
+ * - the block's parent block element is the root component: inline, a
+ *   database always sits in a note; the full page's root
+ *   (`affine-database-page-root`) renders the block directly;
+ * - its scroll container holds a `<doc-title>` whose `body-block-id` names
+ *   this block (`<doc-title .bodyBlockId>`, reflected): the page heading the
+ *   host composed above it. Without one, the page renders the database as
+ *   inline, its own title row shown.
+ *
+ * The parent test comes first: it fails at once for every inline database,
+ * so a text page never pays for the scroll-container walk.
+ */
+export function isStandaloneDatabase(element, blockId) {
+    const root = element.rootComponent;
+    if (!root)
+        return false;
+    if (element.parentElement?.closest('[data-block-id]') !== root)
+        return false;
+    const container = getScrollContainer(element);
+    return !!container.querySelector(`doc-title[body-block-id="${CSS.escape(blockId)}"]`);
+}

package/dist/_pkgs/affine-database-block/utils/current-view.d.ts

@@ -0,0 +1,11 @@
+import type { DatabaseInitialViewService } from '../service/initial-view.js';
+export declare const currentViewStorage: {
+    getCurrentView: (blockId: string) => string | undefined;
+    setCurrentView: (blockId: string, viewId: string) => void;
+};
+/**
+ * The view a database opens on: the host's choice when the block has it
+ * (`DatabaseInitialViewProvider`), else the one this tab last showed, else
+ * `undefined` (the view manager's first view). Reads only.
+ */
+export declare function initialViewId(blockId: string, exists: (viewId: string) => boolean, host?: DatabaseInitialViewService | null): string | undefined;

package/dist/_pkgs/{affine-block-database → affine-database-block}/utils/current-view.js

@@ -45,3 +45,17 @@ const createCurrentViewStorage = () => {
     };
 };
 export const currentViewStorage = createCurrentViewStorage();
+/**
+ * The view a database opens on: the host's choice when the block has it
+ * (`DatabaseInitialViewProvider`), else the one this tab last showed, else
+ * `undefined` (the view manager's first view). Reads only.
+ */
+export function initialViewId(blockId, exists, host) {
+    const asked = host?.initialView({ blockId });
+    if (asked && exists(asked))
+        return asked;
+    const stored = currentViewStorage.getCurrentView(blockId);
+    if (stored && exists(stored))
+        return stored;
+    return undefined;
+}

package/dist/_pkgs/{affine-block-database → affine-database-block}/view.js

@@ -1,7 +1,7 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { DatabaseBlockModel } from '../affine-model/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
-import { StandaloneCellMetaExtension } from '../data-view/index.js';
+import { StandaloneCellMetaExtension } from '../affine-database-engine/index.js';
 import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { z } from 'zod';

package/dist/_pkgs/{affine-block-database → affine-database-block}/views/index.d.ts

@@ -1,4 +1,4 @@
-import type { ViewMeta } from '../../data-view/index.js';
+import type { ViewMeta } from '../../affine-database-engine/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
  * §6). Calendar stays here: calendar views were creatable until 0.48, so

package/dist/_pkgs/{affine-block-database → affine-database-block}/views/index.js

@@ -1,4 +1,4 @@
-import { viewConverts, viewPresets } from '../../data-view/view-presets/index.js';
+import { viewConverts, viewPresets, } from '../../affine-database-engine/view-presets/index.js';
 /**
  * Every preset a stored `affine:database` view can be drawn with (ADR 0035
  * §6). Calendar stays here: calendar views were creatable until 0.48, so

package/dist/_pkgs/affine-database-engine/core/component/cell-status/cell-status-css.d.ts

@@ -0,0 +1,2 @@
+export declare const cellLoadingStyle: string;
+export declare const cellEmptyStyle: string;

package/dist/_pkgs/affine-database-engine/core/component/cell-status/cell-status-css.js

@@ -0,0 +1,16 @@
+import { css } from '@emotion/css';
+// A cell whose value is on its way: a spinner centred in the cell, the
+// height of a drawn one, never a skeleton (recette 3; the host's rule,
+// ADR-0057 on the Labre side).
+export const cellLoadingStyle = css({
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: '100%',
+    minHeight: '32px',
+    fontSize: '16px',
+});
+export const cellEmptyStyle = css({
+    display: 'block',
+    minHeight: '32px',
+});

package/dist/_pkgs/{data-view → affine-database-engine}/core/component/cell-status/cell-status.d.ts

@@ -2,7 +2,7 @@ import { type TemplateResult } from 'lit';
 import type { Cell } from '../../view-manager/cell.js';
 /**
  * What a cell container draws INSTEAD of its renderer while the cell is not
- * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `ready` (ADR 0035 §9e): a spinner while `pending`, an empty cell on
  * `error`. `undefined` when ready, so the container mounts its renderer as in
  * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
  * value never arrived from being edited over.

package/dist/_pkgs/{data-view → affine-database-engine}/core/component/cell-status/cell-status.js

@@ -1,8 +1,9 @@
+import { LoadingIcon } from '../../../../affine-components/icons/index.js';
 import { html } from 'lit';
-import { cellEmptyStyle, cellSkeletonStyle } from './cell-status-css.js';
+import { cellEmptyStyle, cellLoadingStyle } from './cell-status-css.js';
 /**
  * What a cell container draws INSTEAD of its renderer while the cell is not
- * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `ready` (ADR 0035 §9e): a spinner while `pending`, an empty cell on
  * `error`. `undefined` when ready, so the container mounts its renderer as in
  * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
  * value never arrived from being edited over.
@@ -13,11 +14,12 @@ export function renderCellStatus(cell) {
         return undefined;
     if (status === 'pending') {
         return html `<span
-      class="${cellSkeletonStyle}"
-      data-testid="dv-cell-skeleton"
+      class="${cellLoadingStyle}"
+      data-testid="dv-cell-loading"
       data-cell-status="pending"
       aria-busy="true"
-    ></span>`;
+      >${LoadingIcon()}</span
+    >`;
     }
     return html `<span class="${cellEmptyStyle}" data-cell-status="error"></span>`;
 }

package/dist/_pkgs/{data-view → affine-database-engine}/core/utils/menu-title.js

@@ -1,22 +1,22 @@
 import { ArrowLeftBigIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit';
 export const menuTitle = (name, onBack) => {
-    return html `
-    <div
-      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
-    >
-      <div
-        @click=${onBack}
-        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
-        style="display:flex;"
-      >
-        ${ArrowLeftBigIcon()}
-      </div>
-      <div
-        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
-      >
-        ${name}
-      </div>
-    </div>
+    return html `
+    <div
+      style="display:flex;align-items:center;gap: 4px;padding: 3px 3px 3px 2px"
+    >
+      <div
+        @click=${onBack}
+        class="dv-icon-20 dv-hover dv-pd-2 dv-round-4"
+        style="display:flex;"
+      >
+        ${ArrowLeftBigIcon()}
+      </div>
+      <div
+        style="font-weight:500;font-size: 14px;line-height: 22px;color: var(--affine-text-primary-color)"
+      >
+        ${name}
+      </div>
+    </div>
   `;
 };

package/dist/_pkgs/{data-view → affine-database-engine}/core/view/open-in.d.ts

@@ -19,7 +19,7 @@ export declare function viewOpenIn(data: object | undefined): DatabaseViewOpenIn
 export declare function viewOpenInSet(view: SingleView, openIn: DatabaseViewOpenIn): boolean;
 /**
  * Whether the source says its rows are pages (`rowsAreDocuments`, on the
- * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * hosted source of `database/block`, ADR 0035 §9a). Only then does a row
  * open where `openIn` says, so only then is the setting offered: a
  * block-backed row keeps the detail panel whatever the view stores. Read
  * structurally because the flag is declared above this package.

package/dist/_pkgs/{data-view → affine-database-engine}/core/view/open-in.js

@@ -28,7 +28,7 @@ export function viewOpenInSet(view, openIn) {
 }
 /**
  * Whether the source says its rows are pages (`rowsAreDocuments`, on the
- * hosted source of `blocks/database`, ADR 0035 §9a). Only then does a row
+ * hosted source of `database/block`, ADR 0035 §9a). Only then does a row
  * open where `openIn` says, so only then is the setting offered: a
  * block-backed row keeps the detail panel whatever the view stores. Read
  * structurally because the flag is declared above this package.

package/dist/_pkgs/{data-view → affine-database-engine}/core/view-manager/index.d.ts

@@ -6,3 +6,5 @@ export * from './view-manager.js';
 export * from './properties-panel-opener.js';
 export * from './view-creation.js';
 export * from './new-row-menu-opener.js';
+export * from './view-settings-menu.js';
+export * from './page-layout.js';

package/dist/_pkgs/{data-view → affine-database-engine}/core/view-manager/index.js

@@ -6,3 +6,5 @@ export * from './view-manager.js';
 export * from './properties-panel-opener.js';
 export * from './view-creation.js';
 export * from './new-row-menu-opener.js';
+export * from './view-settings-menu.js';
+export * from './page-layout.js';

package/dist/_pkgs/affine-database-engine/core/view-manager/page-layout.d.ts

@@ -0,0 +1,12 @@
+import type { ReadonlySignal } from '@preact/signals-core';
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views:
+ * `true` while the views are the page itself (a database's full page, ADR
+ * 0035 amendment of 2026-10-28). A table then grows to its columns' width
+ * and its column header sticks natively to the page's scroller, which
+ * scrolls both ways; data-view's script leaves that header alone.
+ *
+ * Absent reads `false`, the 0.61 inline table. Set by the database block
+ * from facts it measures, never stored.
+ */
+export declare const PageLayoutKey: import("../../../global/di/types.js").ServiceIdentifier<ReadonlySignal<boolean>> & (<U extends ReadonlySignal<boolean> = ReadonlySignal<boolean>>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/affine-database-engine/core/view-manager/page-layout.js

@@ -0,0 +1,12 @@
+import { createIdentifier } from '../../../global/di/index.js';
+/**
+ * Set on a data source (`serviceSet`) by the block that hosts its views:
+ * `true` while the views are the page itself (a database's full page, ADR
+ * 0035 amendment of 2026-10-28). A table then grows to its columns' width
+ * and its column header sticks natively to the page's scroller, which
+ * scrolls both ways; data-view's script leaves that header alone.
+ *
+ * Absent reads `false`, the 0.61 inline table. Set by the database block
+ * from facts it measures, never stored.
+ */
+export const PageLayoutKey = createIdentifier('DataViewPageLayout');

package/dist/_pkgs/affine-database-engine/core/view-manager/view-settings-menu.d.ts

@@ -0,0 +1,32 @@
+import type { MenuConfig, PopupTarget } from '../../../affine-components/context-menu/index.js';
+import type { BlockStdScope } from '../../../std/index.js';
+import type { ExtensionType } from '../../../store/index.js';
+import type { Wording } from '../utils/wording.js';
+import type { DataViewUILogicBase } from '../view/data-view-base.js';
+/** What the view settings menu hands a {@link ViewSettingsMenu} when it opens. */
+export interface ViewSettingsMenuContext {
+    /** The editor the view is drawn in. */
+    std: BlockStdScope;
+    dataViewLogic: DataViewUILogicBase;
+    /** Where the view settings menu was popped: a setting's own menu pops there too. */
+    target: PopupTarget;
+    /** Reopens the view settings menu: a setting's "back". */
+    reopen(): void;
+    /** The view settings' own wordings, resolved through the editor's catalogue. */
+    wording: Wording;
+}
+/**
+ * Entries of the view settings menu that something above data-view knows
+ * how to offer (ADR 0035 amendment of 2026-10-28): the `core-database`
+ * bundle registers one from its tooling extension for "Source", which needs
+ * the data-source picker it alone reads. Drawn in the Layout group, after
+ * "Layout" (Notion's order: Layout, Source). A registry between library
+ * packages, never filled by a host, so it has no row in the seams table.
+ * Absent, or answering `undefined` for a view it does not handle, the menu
+ * is the 0.61 one.
+ */
+export interface ViewSettingsMenu {
+    items(context: ViewSettingsMenuContext): MenuConfig[] | undefined;
+}
+export declare const ViewSettingsMenuIdentifier: import("../../../global/di/types.js").ServiceIdentifier<ViewSettingsMenu> & (<U extends ViewSettingsMenu = ViewSettingsMenu>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare function ViewSettingsMenuExtension(menu: ViewSettingsMenu): ExtensionType;

package/dist/_pkgs/affine-database-engine/core/view-manager/view-settings-menu.js

@@ -0,0 +1,9 @@
+import { createIdentifier } from '../../../global/di/index.js';
+export const ViewSettingsMenuIdentifier = createIdentifier('DataViewViewSettingsMenu');
+export function ViewSettingsMenuExtension(menu) {
+    return {
+        setup: di => {
+            di.override(ViewSettingsMenuIdentifier, () => menu);
+        },
+    };
+}

package/dist/_pkgs/{data-view → affine-database-engine}/property-presets/number/cell-renderer.d.ts

@@ -4,12 +4,30 @@ export declare class NumberCell extends BaseCellRenderer<number, number, NumberP
     private accessor _inputEle;
     private _getFormattedString;
     private readonly _keydown;
+    /**
+     * The formatted text the input opened with, bound while editing: a value
+     * committed while typing must not reformat the input under the caret
+     * (`1,` typed, `1` committed, the comma kept).
+     */
+    private _opened;
+    /** The number the editor opened with, then the last one committed: a
+     *  commit writes only a change (recette 3, P3-5). */
+    private _base;
+    private _baseSet;
+    private readonly _typing;
+    /** Parsed input; `null` for text that is not a number yet. */
+    private _parse;
+    private _changed;
+    /** While typing: a number commits, a half-typed one waits, the input is
+     *  left as typed. */
+    private _commitTyped;
     private readonly _setValue;
     focusEnd: () => void;
     _blur(): void;
     _focus(): void;
     afterEnterEditingMode(): void;
     beforeExitEditingMode(): void;
+    disconnectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
 }
 export declare const numberPropertyConfig: import("../../index.js").PropertyMetaConfig<"number", {

package/dist/_pkgs/{data-view → affine-database-engine}/property-presets/number/cell-renderer.js

@@ -39,6 +39,7 @@ import { BaseCellRenderer } from '../../core/property/index.js';
 import { createFromBaseCellRenderer } from '../../core/property/renderer.js';
 import { stopPropagation } from '../../core/utils/event.js';
 import { createIcon } from '../../core/utils/uni-icon.js';
+import { TypingCommit } from '../typing-commit.js';
 import { numberInputStyle, numberStyle } from './cell-renderer-css.js';
 import { numberPropertyModelConfig } from './define.js';
 import { formatNumber, parseNumber, } from './utils/formatter.js';
@@ -63,14 +64,15 @@ let NumberCell = (() => {
                     });
                 }
             });
+            this._baseSet = false;
+            this._typing = new TypingCommit(() => this._commitTyped());
             this._setValue = (str = this._inputEle?.value) => {
-                if (!str) {
-                    this.valueSetNextTick(undefined);
+                this._typing.cancel();
+                // No input, nothing typed: never read as a cleared value.
+                if (str === undefined)
                     return;
-                }
-                const enableNewFormatting = this.view.featureFlags$.value.enable_number_formatting;
-                const value = enableNewFormatting ? parseNumber(str) : parseFloat(str);
-                if (isNaN(value)) {
+                const value = this._parse(str);
+                if (value === null) {
                     if (this._inputEle) {
                         this._inputEle.value = this.value
                             ? this._getFormattedString(this.value)
@@ -78,10 +80,11 @@ let NumberCell = (() => {
                     }
                     return;
                 }
-                if (this._inputEle) {
+                if (this._inputEle && value !== undefined) {
                     this._inputEle.value = this._getFormattedString(value);
                 }
-                this.valueSetNextTick(value);
+                if (this._changed(value))
+                    this.valueSetNextTick(value);
             };
             this.focusEnd = () => {
                 if (!this._inputEle)
@@ -111,6 +114,34 @@ let NumberCell = (() => {
                     : value.toString()
                 : '';
         }
+        /** Parsed input; `null` for text that is not a number yet. */
+        _parse(str) {
+            if (!str)
+                return undefined;
+            const enableNewFormatting = this.view.featureFlags$.value.enable_number_formatting;
+            const value = enableNewFormatting ? parseNumber(str) : parseFloat(str);
+            return isNaN(value) ? null : value;
+        }
+        _changed(value) {
+            const base = this._baseSet ? this._base : this.value;
+            if (value === base)
+                return false;
+            this._base = value;
+            this._baseSet = true;
+            return true;
+        }
+        /** While typing: a number commits, a half-typed one waits, the input is
+         *  left as typed. */
+        _commitTyped() {
+            this._typing.cancel();
+            const input = this._inputEle;
+            if (!input)
+                return;
+            const value = this._parse(input.value);
+            if (value === null || !this._changed(value))
+                return;
+            this.valueSetImmediate(value);
+        }
         _blur() {
             this.selectCurrentCell(false);
         }
@@ -125,14 +156,21 @@ let NumberCell = (() => {
         beforeExitEditingMode() {
             this._setValue();
         }
+        disconnectedCallback() {
+            if (this.isEditing$?.peek())
+                this._commitTyped();
+            this._typing.cancel();
+            super.disconnectedCallback();
+        }
         render() {
             if (this.isEditing$.value) {
-                const formatted = this.value ? this._getFormattedString(this.value) : '';
+                this._opened ??= this.value ? this._getFormattedString(this.value) : '';
                 return html `<input
         type="text"
         autocomplete="off"
-        .value="${formatted}"
+        .value="${this._opened}"
         @keydown="${this._keydown}"
+        @input="${() => this._typing.schedule()}"
         @blur="${this._blur}"
         @focus="${this._focus}"
         class="${numberInputStyle} number"
@@ -140,6 +178,9 @@ let NumberCell = (() => {
       />`;
             }
             else {
+                this._opened = undefined;
+                this._base = undefined;
+                this._baseSet = false;
                 return html ` <div class="${numberStyle} number">
         ${this._getFormattedString()}
       </div>`;

package/dist/_pkgs/affine-database-engine/property-presets/text/cell-renderer.d.ts

@@ -0,0 +1,33 @@
+import { BaseCellRenderer } from '../../core/property/index.js';
+/**
+ * The plain-text cell (a hosted source's text and title columns, the title
+ * band's text). What is typed is committed while typing (after a pause),
+ * when the input loses the focus, when the cell leaves the DOM and when the
+ * cell exits editing (Enter, Escape, Tab, another cell): leaving by a path
+ * no view reports, a click outside the editor, lost the edit (recette 3,
+ * P3-5, `text-cell-commit.unit.spec.ts`). Escape commits too: what was typed
+ * is kept, as in the table before. A commit writes only what changed since
+ * the editor opened or last committed, so an exit without typing writes
+ * nothing and a value another peer wrote meanwhile is not overwritten.
+ */
+export declare class TextCell extends BaseCellRenderer<string, string> {
+    private accessor _inputEle;
+    /**
+     * The text the input opened with, bound while editing: a value the
+     * source echoes back mid-typing (a commit while typing, a remote write)
+     * must not rewrite the input under the caret.
+     */
+    private _opened;
+    /** The last text handed to the source in this edit session. */
+    private _sent;
+    private readonly _typing;
+    private readonly _keydown;
+    private readonly _onBlur;
+    private _commit;
+    focusEnd: () => void;
+    afterEnterEditingMode(): void;
+    beforeExitEditingMode(): void;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export declare const textPropertyConfig: import("../../index.js").PropertyMetaConfig<"text", {}, string, string>;