@dineug/erd-editor 4.1.0 → 4.2.0

package/dist/components/erd/canvas/table/Table.d.ts

@@ -25,6 +25,12 @@ export type TableProps = {
      * reads the group list once for every table; a table drawn alone reads its own.
      */
     tableGroupId?: string;
+    /**
+     * Whether the cells write what the dictionaries' checks find in their colours,
+     * on unless the scene says otherwise. Only the document scene outside a diff
+     * pane draws them, and an export turns them off.
+     */
+    checkMarks?: boolean;
 };
 declare const Table: FC<TableProps>;
 export default Table;

package/dist/components/erd/canvas/table/blankLogicalName.d.ts

@@ -0,0 +1,19 @@
+import { RootState } from '../../../../engine/state';
+import { PlainMessageKey } from '../../../../i18n/translate';
+/** What a logical name cell shows, dimmed, while its logical name is blank. */
+export type BlankLogicalName = {
+    /** The name drawn in the logical name's place, '' while there is none to draw. */
+    standIn: string;
+    /** The placeholder shown while there is no stand-in. */
+    key: PlainMessageKey;
+};
+/**
+ * The logical view sets the logical name cell in the name's place, so a blank
+ * one shows the name, or the name's own placeholder while that is blank too.
+ * The view of both shows the logical name's placeholder beside the name.
+ *
+ * @example
+ * const { standIn, key } = blankLogicalName(settings, table.name, 'common.placeholder.table');
+ */
+export declare function blankLogicalName(settings: Pick<RootState['settings'], 'nameViewMode'>, name: string, nameKey: PlainMessageKey): BlankLogicalName;
+//# sourceMappingURL=blankLogicalName.d.ts.map

package/dist/components/erd/canvas/table/cellLayout.d.ts

@@ -4,8 +4,8 @@ import { Table } from '../../../../internal-types';
 import { Theme } from '../../../../themes/tokens';
 import { ColumnWidth } from '../../../../utils/calcTable';
 import { GeometrySource } from '../../../../utils/draw-relationship/geometrySource';
-/** The four widths a column row measures from its table; the rest are fixed. */
-export type ColumnCellWidths = Pick<ColumnWidth, 'comment' | 'dataType' | 'default' | 'name'>;
+/** The six widths a column row measures from its table; the rest are fixed. */
+export type ColumnCellWidths = Pick<ColumnWidth, 'comment' | 'dataType' | 'default' | 'domain' | 'logicalName' | 'name'>;
 /** One editable box on a table, positioned inside the table's own group. */
 export type CellSlot = {
     focusType: FocusType;
@@ -93,13 +93,13 @@ export declare function getWidthComment(state: RootState, table: Table): number;
 /**
  * The name and comment boxes past a header's table icon. One list feeds the
  * scene that draws them and the overlay that edits them, so an editor never
- * sits anywhere but on the text it replaces. A view draws the name alone.
+ * sits anywhere but on the text it replaces. A view draws the names alone.
  */
 export declare function getHeaderCellSlots(state: RootState, table: Table, source?: GeometrySource): CellSlot[];
 /**
  * The cells of one column row, in the order the settings put them and at the x
  * each lands on once the ones before it have taken their width. A view lays
- * out the name and the type and reads neither the show bits nor the order.
+ * out the cells its name view names and reads neither the show bits nor the order.
  */
 export declare function getColumnCellSlots(state: RootState, widths: ColumnCellWidths, source?: GeometrySource): ColumnCellSlot[];
 //# sourceMappingURL=cellLayout.d.ts.map

package/dist/components/erd/canvas/table/column/Column.d.ts

@@ -1,5 +1,5 @@
 import { FC } from '@dineug/r-html';
-import { SceneMouseEvent } from '../../sceneTokens';
+import { ScenePointerEvent } from '../../sceneTokens';
 import { DiffPaths } from '../../../diff-viewer/diff';
 import { Column } from '../../../../../internal-types';
 import { GeometrySource } from '../../../../../utils/draw-relationship/geometrySource';
@@ -22,9 +22,9 @@ export type ColumnProps = {
      */
     diffPaths?: DiffPaths | null;
     /**
-     * How far the light has come up on the card this row is drawn in, which is
-     * what the row tint and the type cell above are both drawn at. One number, so
-     * the two of them come up over the one span of time and a document row reads none of it.
+     * How far the light has come up on the card this row is drawn in, which a
+     * related row's tint is drawn at, so it comes up with the card's border and
+     * glow over the one span of time. A document row reads none of it.
      */
     litAlpha?: number;
     /**
@@ -45,6 +45,10 @@ export type ColumnProps = {
     widthDataType: number;
     widthDefault: number;
     widthComment: number;
+    /** The logical name's own cell, 0 while the name view lays out none. */
+    widthLogicalName?: number;
+    /** The domain's own cell, 0 while its show bit is off. */
+    widthDomain?: number;
     /**
      * The room the table keeps for alternate key marks after the last cell, 0
      * while it draws none; the same for every row, so the marks stay in line.
@@ -52,6 +56,11 @@ export type ColumnProps = {
     widthAlternateKey?: number;
     /** The mark this row carries in that room, AK1.2 or several comma joined. */
     alternateKey?: string;
+    /**
+     * The name and type cells' marks, under whichever focus the name view gives
+     * them: the logical view's name cell takes the logical name's, and its type
+     * cell the domain's while the domain has no cell of its own.
+     */
     focusName: boolean;
     focusDataType: boolean;
     focusNotNull: boolean;
@@ -59,6 +68,9 @@ export type ColumnProps = {
     focusComment: boolean;
     focusUnique: boolean;
     focusAutoIncrement: boolean;
+    /** The marks of the logical name and domain cells, which a row lays out in some views alone. */
+    focusLogicalName?: boolean;
+    focusDomain?: boolean;
     sharedFocusName: string | null;
     sharedFocusDataType: string | null;
     sharedFocusNotNull: string | null;
@@ -66,22 +78,37 @@ export type ColumnProps = {
     sharedFocusComment: string | null;
     sharedFocusUnique: string | null;
     sharedFocusAutoIncrement: string | null;
+    sharedFocusLogicalName?: string | null;
+    sharedFocusDomain?: string | null;
     editName: boolean;
     editDataType: boolean;
     editDefault: boolean;
     editComment: boolean;
+    editLogicalName?: boolean;
+    editDomain?: boolean;
     hovered?: boolean;
     /** The placeholder row for a column dragged in from another table. */
     ghost?: boolean;
+    /**
+     * Whether the name cells write what the dictionaries' checks find in their
+     * colours, which the table decides for every row it draws.
+     */
+    checkMarks?: boolean;
     /** Drawn inside a copy of the table, which owns none of its ids. */
     preview?: boolean;
     editorFocused?: boolean;
+    /**
+     * Whether the row carries the handle a column drag starts from, outside the
+     * table's left edge. The table gives it to its focused row alone, and only
+     * where a reader can reorder: the document, unlocked, never a copy.
+     */
+    dragHandle?: boolean;
     /**
      * The one pair of callbacks the scene keeps. A drop lands between siblings,
      * so the table that owns the order is the only thing that can judge one, and
      * the row can only say that a drag of it started and that it ended.
      */
-    onDragstart?: (columnId: string, event: SceneMouseEvent) => void;
+    onDragstart?: (columnId: string, event: ScenePointerEvent) => void;
     onDragend?: () => void;
 };
 declare const Column: FC<ColumnProps>;

package/dist/components/erd/canvas/table/dictionaryMarks.d.ts

@@ -0,0 +1,29 @@
+import { DictionaryCheckField, DictionaryCheckLevel } from '../../../../engine/modules/dictionary/checks';
+import { RxStore } from '../../../../engine/rx-store';
+import { Column, Table } from '../../../../internal-types';
+import { Theme } from '../../../../themes/tokens';
+/** The colour a check level writes a cell's text in: red for an error, amber for a warning. */
+export declare const dictionaryMarkFill: (theme: Theme, level: DictionaryCheckLevel | null) => string | null;
+/**
+ * The mark while it reads at 4.5:1 on the header fill under it, else null, so
+ * the header's own black or white takes its place: a group's colour is the
+ * reader's pick, and a mark of a near hue would hide the name it marks.
+ */
+export declare function readableMarkFill(mark: string | null, background: string): string | null;
+/**
+ * The colour a header cell's text takes for what the checks find in the field
+ * it draws, null for nothing found. Empty dictionaries find nothing.
+ *
+ * @example
+ * const fill = tableMarkFill(store, theme, table, 'logicalName');
+ */
+export declare function tableMarkFill(store: RxStore, theme: Theme, table: Table, field: DictionaryCheckField): string | null;
+/**
+ * The colour a row cell's text takes for what the checks find in the field it
+ * draws, null for nothing found, as a header cell's is.
+ *
+ * @example
+ * const fill = columnMarkFill(store, theme, column, 'name');
+ */
+export declare function columnMarkFill(store: RxStore, theme: Theme, column: Column, field: DictionaryCheckField): string | null;
+//# sourceMappingURL=dictionaryMarks.d.ts.map

package/dist/components/erd/canvas/table/useFocusTable.d.ts

@@ -4,5 +4,6 @@ export declare function useFocusTable(ctx: Ctx, tableId: string): {
     hasFocus: (focusType: FocusType, columnId?: string) => boolean;
     hasEdit: (focusType: FocusType, columnId?: string) => boolean;
     hasSelectColumn: (columnId: string) => boolean;
+    hasFocusColumn: (columnId: string) => boolean;
 };
 //# sourceMappingURL=useFocusTable.d.ts.map

package/dist/components/erd/diff-viewer/diff-tree/DiffTree.styles.d.ts

@@ -6,6 +6,7 @@ export declare const empty: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const sash: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const rowIcon: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const name: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const after: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const count: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const status: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const visuallyHidden: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/erd/diff-viewer/diff-tree/diffTreeModel.d.ts

@@ -21,7 +21,10 @@ export type DiffTree = {
 };
 /** A row's id: the current entity's, or the saved one's where it is gone. */
 export declare const entryNodeId: (entry: DiffEntry) => string;
-/** Whether a name filter keeps an entry: its current name or the saved one holds what is typed, in any case. */
+/**
+ * Whether a name filter keeps an entry: its current name or the saved one,
+ * or either logical name, holds what is typed, in any case and in any view.
+ */
 export declare function matchesFilter(entry: DiffEntry, filter: string): boolean;
 /**
  * The tree a diff lists: Tables, Table Groups and Memos as the Explorer has

package/dist/components/erd/erd-context-menu/menus/nameViewMenus.d.ts

@@ -0,0 +1,22 @@
+import { AppContext } from '../../../appContext';
+import { NameViewMode } from '../../../../constants/schema';
+import { I18n, PlainMessageKey } from '../../../../i18n/translate';
+import { ValuesType } from '../../../../internal-types';
+type Menu = {
+    labelKey: PlainMessageKey;
+    value: ValuesType<typeof NameViewMode>;
+};
+/** The three name views, by the name a reader picks each one by. */
+export declare const menus: ReadonlyArray<Menu>;
+/**
+ * The Name View rows, the view in force checked. A pick switches the reader's
+ * own view, and the document's once its lock is off in an editor that is not
+ * readonly.
+ */
+export declare function createNameViewMenus({ store }: AppContext, i18n?: Pick<I18n, 't'>): {
+    checked: boolean;
+    name: string;
+    onClick: () => void;
+}[];
+export {};
+//# sourceMappingURL=nameViewMenus.d.ts.map

package/dist/components/erd/floating-toolbar/FloatingToolbar.d.ts

@@ -5,7 +5,7 @@ export type FloatingToolbarProps = {
 };
 /**
  * The bar over the bottom of the canvas: which of the two a press means, what
- * to add, the zoom, the notation the next relationship is drawn in, zen mode,
+ * to add, the zoom, the notation the next relationship is drawn in, the name view, zen mode,
  * and which way the content lies once the screen holds none. It is the one surface zen mode leaves standing.
  */
 declare const FloatingToolbar: FC<FloatingToolbarProps>;

package/dist/components/erd/floating-toolbar/nameViewDropdown.d.ts

@@ -0,0 +1,16 @@
+import { DOMTemplateLiterals } from '@dineug/r-html';
+import { Ctx } from '../../../internal-types';
+export type NameViewDropdown = {
+    /** The button in the bar, which names the view in force. */
+    trigger: () => DOMTemplateLiterals;
+    /** The menu over it, drawn beside the bar, whose transform would move it. */
+    menu: () => DOMTemplateLiterals | null;
+    close: () => void;
+};
+/**
+ * The Name View list a floating bar offers over itself, the view in force
+ * checked. A pick switches the reader's own view, and the document's once its
+ * lock is off, as the canvas menu's does (toNameViewModeAction).
+ */
+export declare function useNameViewDropdown(ctx: Ctx): NameViewDropdown;
+//# sourceMappingURL=nameViewDropdown.d.ts.map

package/dist/components/erd/floating-toolbar/nameViewDropdown.styles.d.ts

@@ -0,0 +1,5 @@
+export declare const trigger: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const label: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hidden: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const menu: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=nameViewDropdown.styles.d.ts.map

package/dist/components/erd/readerNameView.d.ts

@@ -0,0 +1,15 @@
+import { RootState } from '../../engine/state';
+/**
+ * The switch that shows a store opened from the file in the name view its
+ * reader is looking at, since the file holds the view its lock keeps. It
+ * changes that store's screen alone, as a readonly reader's switch does.
+ *
+ * @example
+ * store.dispatchSync(initialLoadJsonAction$(json), readerNameViewAction(store.state, reader));
+ */
+export declare const readerNameViewAction: (opened: RootState, reader: RootState) => import('@dineug/r-html').AnyAction<{
+    value: import('../../internal-types').ValuesType<typeof import('../../constants/schema').NameViewMode>;
+    shared: boolean;
+    editorId: string;
+}>;
+//# sourceMappingURL=readerNameView.d.ts.map

package/dist/components/explorer/explorerTree.d.ts

@@ -15,11 +15,13 @@ export type ExplorerNode = {
     kind: 'table';
     tableId: string;
     name: string;
+    logicalName: string;
 } & NameMatches) | ({
     kind: 'column';
     tableId: string;
     columnId: string;
     name: string;
+    logicalName: string;
     dataType: string;
     primaryKey: boolean;
     foreignKey: boolean;
@@ -49,6 +51,7 @@ export type ExplorerNode = {
     tableGroupId: string;
     tableId: string;
     name: string;
+    logicalName: string;
 } | {
     kind: 'memo';
     memoId: string;
@@ -72,7 +75,7 @@ export declare function buildExplorerTree(state: RootState): ExplorerTreeNode[];
  */
 export declare function matchRowId(match: FindMatch): string;
 /** The rows above a match's row in the search's tree, which must be open for the row to be drawn. */
-export declare function matchAncestorIds({ field, id, tableId }: FindMatch): string[];
+export declare function matchAncestorIds(match: FindMatch): string[];
 export type SearchTree = {
     roots: ExplorerTreeNode[];
     /** Every row with children, which a search shows open unless folded. */

package/dist/components/explorer/fieldIcon.d.ts

@@ -1,5 +1,8 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { FindField } from '../../utils/find-replace';
-/** The icon a result row carries for the kind of text it was found in. */
+/**
+ * The icon a result row carries for the kind of text it was found in. A
+ * logical name draws a column's, since only the column search lists one.
+ */
 export declare function fieldIcon(field: FindField, size?: number): DOMTemplateLiterals;
 //# sourceMappingURL=fieldIcon.d.ts.map

package/dist/components/explorer/matchTarget.d.ts

@@ -4,17 +4,17 @@ import { GeneratorAction } from '../../engine/generator.actions';
 import { RootState } from '../../engine/state';
 import { FindMatch } from '../../utils/find-replace';
 /**
- * Where on the ERD canvas the text of a match is edited: its table, its column
- * cell, its memo or its table group, with the match itself, which a cell too
- * wide for the canvas is scrolled to by. An index goes to the table it is on.
+ * Where on the ERD canvas a match's text is edited: its table, column cell,
+ * memo or table group, with the match, which a cell too wide is scrolled to
+ * by. An index goes to its table, a logical name to the cell the view draws.
  */
 export declare function toErdTarget(match: FindMatch): ErdTarget;
 /**
  * The state as a jump measures it once a replacement is in: the field holding
- * the new text at the width its reducer gives it. A memo, an index or a group
- * name sizes no table, and one the document no longer holds is left as it is.
+ * the new text at the width its reducer gives it, a name a logical name derives
+ * left as it was. A memo, an index or a group name sizes no table.
  */
-export declare function withReplacement(state: RootState, { toWidth }: EngineContext, { field, id, tableId }: FindMatch, value: string): RootState;
+export declare function withReplacement(state: RootState, { toWidth }: EngineContext, match: FindMatch, value: string): RootState;
 /**
  * The jump Replace makes to the next match, in the replacement's own dispatch.
  * A batch is read against the state before it, so the jump measures the table

package/dist/components/export-image/ExportImage.d.ts

@@ -1,4 +1,5 @@
 import { FC } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
 import { ThemeOptions } from '../../themes/radix-ui-theme';
 export type ExportImageProps = {
     /** The gray and accent the editor's preset is built from. */
@@ -13,6 +14,15 @@ export type ExportScale = (typeof EXPORT_SCALES)[number];
 export declare const PREVIEW_MAX_SIDE = 1280;
 /** How long the toggles rest before the preview is drawn again. */
 export declare const PREVIEW_DEBOUNCE_MS = 200;
+/**
+ * The document an image is drawn from: the words and terms left out, which
+ * only the checks read and an image marks none of, and the domains kept,
+ * whose names the logical view's type cells draw.
+ *
+ * @example
+ * const doc = toExportJson(store.state);
+ */
+export declare const toExportJson: (state: RootState) => string;
 /**
  * The export image dialog: a preview, the options, the buttons that write a png
  * or an svg or copy a png, and a close button. The options last for the

package/dist/components/export-image/exportImageActions.d.ts

@@ -32,9 +32,9 @@ export declare function exportImagePng({ emitter }: AppContext, request: ImageRe
  * a failure is reported once the file is done.
  *
  * @example
- * await exportImageSvg(app, { doc, theme, toWidth, i18n }, databaseName);
+ * await exportImageSvg(app, { doc, theme, toWidth, i18n, nameViewMode }, databaseName);
  */
-export declare function exportImageSvg({ emitter }: AppContext, { doc, theme, toWidth, i18n }: SvgRequest, databaseName: string): Promise<void>;
+export declare function exportImageSvg({ emitter }: AppContext, { doc, theme, toWidth, i18n, nameViewMode }: SvgRequest, databaseName: string): Promise<void>;
 /**
  * Puts the document on the clipboard as a png. The clipboard write starts in
  * the click that called this, before any await, so call it from the handler

package/dist/components/flowCenters.d.ts

@@ -1,4 +1,5 @@
 import { AppContext } from './appContext';
+import { CenterStep } from '../engine/modules/editor/state';
 /**
  * Narrows the Flow view to the tables given and their one hop. State alone:
  * the placement loop reads the display set it names and asks for the layout,
@@ -7,4 +8,12 @@ import { AppContext } from './appContext';
 export declare function focusFlowView(app: AppContext, tableIds: string[]): void;
 /** Widens the Flow view back to everything it placed, through that same one channel: state alone. */
 export declare function showAllFlowView(app: AppContext): void;
+/**
+ * Stands the Flow view on the centers a step the way given reaches, through that
+ * same one channel: state alone. With nowhere to go it dispatches nothing, so a
+ * dimmed button or a chord pressed again wakes no sort and drops no set.
+ */
+export declare function stepFlowView(app: AppContext, step: CenterStep): void;
+/** Whether a step the way given would move the Flow view, past the sets it would pass over. */
+export declare function canStepFlowView(app: AppContext, step: CenterStep): boolean;
 //# sourceMappingURL=flowCenters.d.ts.map

package/dist/components/map-columns/nameOf.d.ts

@@ -1,6 +1,14 @@
+import { RootState } from '../../engine/state';
 import { I18n } from '../../i18n/translate';
-/** A table's or column's name as Map Columns and the draw-target buttons write it, unnamed where it has none. */
-export declare const nameOf: (entity: {
+type ViewSettings = Pick<RootState['settings'], 'nameViewMode'>;
+/**
+ * A table's or column's name as Map Columns, the draw-target buttons and the
+ * check sheet write it: the one the name view shows, the name after the
+ * logical name in the view of both, and unnamed where it shows none.
+ */
+export declare function nameOf(entity: {
     name: string;
-} | undefined, { t }: Pick<I18n, "t">) => string;
+    logicalName: string;
+} | undefined, { t }: Pick<I18n, 't'>, settings: ViewSettings): string;
+export {};
 //# sourceMappingURL=nameOf.d.ts.map

package/dist/components/primitives/icon/icons.d.ts

@@ -9,6 +9,7 @@ declare const LUCIDE_ICON: {
     'arrow-right': IconNode;
     'arrow-up': IconNode;
     atom: IconNode;
+    'book-type': IconNode;
     braces: IconNode;
     brackets: IconNode;
     'case-sensitive': IconNode;
@@ -32,6 +33,7 @@ declare const LUCIDE_ICON: {
     folder: IconNode;
     'folder-open': IconNode;
     fullscreen: IconNode;
+    'funnel-x': IconNode;
     'grip-vertical': IconNode;
     group: IconNode;
     hand: IconNode;
@@ -40,7 +42,9 @@ declare const LUCIDE_ICON: {
     languages: IconNode;
     link: IconNode;
     list: IconNode;
+    'list-plus': IconNode;
     'list-tree': IconNode;
+    'list-x': IconNode;
     'loader-circle': IconNode;
     lock: IconNode;
     'lock-open': IconNode;
@@ -77,6 +81,7 @@ declare const LUCIDE_ICON: {
     'triangle-alert': IconNode;
     'undo-2': IconNode;
     ungroup: IconNode;
+    upload: IconNode;
     'wand-sparkles': IconNode;
     waypoints: IconNode;
     'whole-word': IconNode;

package/dist/components/quick-search/actions.d.ts

@@ -13,6 +13,8 @@ export type Action = {
     shortcut?: string;
     /** The table a row jumps to, whose keyword names the kind of row, not the table. */
     tableId?: string;
+    /** A table row's own names, its name and logical name, which a search reads whatever the name view shows. */
+    tableNames?: string[];
     /** What choosing the row types into the input, which stays open, instead of running a command. */
     insert?: string;
     /** The English of a translated name and keywords, each its own text, which a search also reads and the list never shows. */
@@ -64,7 +66,7 @@ export declare function createScopeActions(app: AppContext, i18n?: I18n, prefere
 export declare function createPreferenceActions(i18n: I18n, { appearance, locale }: PalettePreferences): Action[];
 /** The row for one field a search found, saying where it is, which stands the reader on it when chosen. */
 export declare function createMatchAction(state: RootState, match: FindMatch, i18n?: I18n): Action;
-/** The five tabs the Tab row opens, each but the one shown. */
+/** The six tabs the Tab row opens, each but the one shown. */
 export declare function createTabActions(i18n?: I18n): Action[];
 export {};
 //# sourceMappingURL=actions.d.ts.map

package/dist/components/quick-search/scopedActions.d.ts

@@ -21,8 +21,8 @@ export declare function paletteRows(app: AppContext, found: Action[], { scope, k
 export declare function rankTableActions(found: Action[], keyword: string): Action[];
 /**
  * One row for each field of the kinds given holding the keyword, Hangul letters
- * too, or for every column or text that is not empty while there is none, the
- * table part narrowing a column search; the list draws only the rows in view.
+ * too, or for every column name or text that is not empty while there is none,
+ * the table part narrowing a column search; the list draws only the rows in view.
  */
 export declare function createFieldActions(app: AppContext, fields: FindField[], keyword: string, table?: string | null, i18n?: I18n): Action[];
 /** The prefixes as rows, each typing its character into the input when chosen; a keyword fuzzes them. */

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.d.ts

@@ -16,8 +16,8 @@ export type SchemaSQLOptionsProps = {
 };
 /**
  * The options beside the Schema SQL: the database and the bracket, then this
- * window's statements, header and tables, then the scripts the document
- * saves, and the buttons that save and copy the text.
+ * window's statements, header, logical name comments and tables, then the
+ * scripts the document saves, and the buttons that save and copy the text.
  */
 declare const SchemaSQLOptions: FC<SchemaSQLOptionsProps>;
 export default SchemaSQLOptions;

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.styles.d.ts

@@ -11,6 +11,8 @@ export declare const group: import('@dineug/r-html').CSSTemplateLiterals;
 /** A group under a rule, drawn halfway into the gap above it. */
 export declare const separated: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
+/** A label beside its switch: the label wraps, the switch keeps its size and the label takes the press. */
+export declare const toggle: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const column: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const caption: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const note: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/schema-sql/schemaSQLView.d.ts

@@ -19,6 +19,8 @@ export type SchemaSQLView = {
     statements: SchemaSQLStatements;
     /** The header asked for, resolved the same way. */
     header: SchemaSQLHeader;
+    /** Whether an empty comment writes the logical name; off at first. */
+    logicalNameAsComment: boolean;
     /** Replaced whole, never changed in place, so a watcher hears one change. */
     tables: SchemaSQLTableChoice;
     panel: OptionsPanelState;

package/dist/components/settings/lockSettingRows.d.ts

@@ -1,10 +1,11 @@
+import { LockSettingType as LockSettingBit } from '@dineug/erd-editor-schema';
 import { RootState } from '../../engine/state';
 import { I18n, PlainMessageKey } from '../../i18n/translate';
 type LockedValues = RootState['settings']['lockedValues'];
 type Translator = Pick<I18n, 't'>;
 export type LockSettingRow = {
     nameKey: PlainMessageKey;
-    lockSettingType: number;
+    lockSettingType: LockSettingBit;
     toText: (values: LockedValues, i18n: Translator) => string;
 };
 /**

package/dist/components/table-view/column/column-domain/ColumnDomain.d.ts

@@ -0,0 +1,19 @@
+import { FC, Ref } from '@dineug/r-html';
+import { AppContext } from '../../../appContext';
+export type ColumnDomainProps = {
+    app?: Ref<AppContext>;
+    tableId: string;
+    columnId: string;
+    width: number;
+    placeholder: string;
+    onBlur?: (event: FocusEvent) => void;
+    onEditEnd?: () => void;
+};
+/**
+ * The domain editor of a row: a search over the domain sheet by name that only
+ * picks, never writing what is typed. A pick links the domain with its type in
+ * one dispatch, and None unlinks; it opens on the row of the domain linked.
+ */
+declare const ColumnDomain: FC<ColumnDomainProps>;
+export default ColumnDomain;
+//# sourceMappingURL=ColumnDomain.d.ts.map

package/dist/components/table-view/column/column-domain/domainOptions.d.ts

@@ -0,0 +1,13 @@
+import { RootState } from '../../../../engine/state';
+/** A row of a domain picker: a domain by its id and name, or the empty id that unlinks. */
+export type DomainOption = {
+    id: string;
+    name: string;
+};
+/**
+ * The rows a search offers: every named domain in sheet order after the row
+ * that unlinks while nothing is typed, else the domains whose names hold the
+ * text in any case; none at all while the sheet lists no named domain.
+ */
+export declare function searchDomainOptions(state: RootState, typed: string): DomainOption[];
+//# sourceMappingURL=domainOptions.d.ts.map

package/dist/components/table-view/column/column-logical-name/ColumnLogicalName.d.ts

@@ -0,0 +1,22 @@
+import { FC, Ref } from '@dineug/r-html';
+import { AppContext } from '../../../appContext';
+export type ColumnLogicalNameProps = {
+    app?: Ref<AppContext>;
+    tableId: string;
+    /** The column whose logical name is edited, null for the table's own. */
+    columnId: string | null;
+    width: number;
+    value: string;
+    placeholder: string;
+    onInput?: (event: InputEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onEditEnd?: () => void;
+};
+/**
+ * The logical name editor of a header or a row: each key writes the text, the
+ * terms its start names drop under it, and a term picked writes it with its
+ * derivation; the name is derived once more as the editor closes on a change.
+ */
+declare const ColumnLogicalName: FC<ColumnLogicalNameProps>;
+export default ColumnLogicalName;
+//# sourceMappingURL=ColumnLogicalName.d.ts.map

package/dist/components/table-view/column/column-logical-name/ColumnLogicalName.styles.d.ts

@@ -0,0 +1,4 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hint: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hintItem: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ColumnLogicalName.styles.d.ts.map