@dineug/erd-editor 3.10.0 → 4.0.0

package/dist/utils/generator-code/columnTypes.d.ts

@@ -0,0 +1,99 @@
+import { PrimitiveType } from '../../constants/sql/dataType';
+/**
+ * The value a column's element holds, apart from any driver or library that
+ * reads it: integers by width and sign, floats by width, each date and time.
+ */
+export type ColumnScalar = 'bool' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64' | 'decimal' | 'string' | 'bytes' | 'uuid' | 'json' | 'date' | 'time' | 'timeTz' | 'dateTime' | 'dateTimeUtc' | 'dateTimeOffset' | 'interval';
+/** The fields an interval holds: years and months, days to seconds, or both. */
+export type IntervalFields = 'yearMonth' | 'dayTime' | 'mixed';
+/** A network address type, by what it holds. */
+export type NetworkType = 'ipv4' | 'ipv6' | 'inet' | 'cidr' | 'macaddr' | 'macaddr8';
+export type ColumnType = {
+    scalar: ColumnScalar;
+    /** The element's data type as written, a PostgreSQL array's suffix gone. */
+    element: string;
+    /**
+     * The element's type name, lower case, its arguments gone, and on MySQL and
+     * MariaDB its UNSIGNED, ZEROFILL and SIGNED too.
+     */
+    base: string;
+    /** The element's arguments when all are numbers: numeric(10,2) gives [10, 2]. */
+    args: number[];
+    arrayDepth: number;
+    /** An integer's width, 24 for MySQL's MEDIUMINT; null for any other scalar. */
+    bits: 8 | 16 | 24 | 32 | 64 | null;
+    /** Whether the database's vendor list names the element's type. */
+    isListed: boolean;
+    /** MySQL and MariaDB: UNSIGNED, ZEROFILL or SERIAL in the type. */
+    isUnsigned: boolean;
+    /** A type that numbers its rows itself: PostgreSQL's serials, MySQL's SERIAL. */
+    isSerial: boolean;
+    isFloat: boolean;
+    /** money or smallmoney, which PostgreSQL prints in the session's currency. */
+    isMoney: boolean;
+    /** SQL Server's uniqueidentifier, which holds any 16 bytes, not only an RFC UUID. */
+    isGuid: boolean;
+    /** SQL Server's timestamp and rowversion, eight bytes it writes on every change. */
+    isRowVersion: boolean;
+    /** A Snowflake or Databricks VARIANT, OBJECT, ARRAY, MAP or STRUCT. */
+    isSemiStructured: boolean;
+    /** A PostgreSQL bit string, which drivers read as text such as 1010. */
+    isBitString: boolean;
+    /** PostgreSQL's xid, cid and xid8, integers node-postgres hands over as text. */
+    isTextInteger: boolean;
+    /** Databricks' VOID, which holds nothing but NULL. */
+    isNullOnly: boolean;
+    /** A character type's declared length, BYTE or CHAR units alike; else null. */
+    length: number | null;
+    /** A decimal or NUMBER's declared precision, a star being 38; else null. */
+    precision: number | null;
+    /** A decimal or NUMBER's declared scale; null where none is written. */
+    scale: number | null;
+    interval: IntervalFields | null;
+    network: NetworkType | null;
+    /** An ENUM's members, each read as MySQL reads a string literal. */
+    enumMembers: string[] | null;
+    /** A SET's members, each read as MySQL reads a string literal. */
+    setMembers: string[] | null;
+};
+/** The binary types, which every database hands over as bytes. */
+export declare const BINARY_TYPES: ReadonlySet<string>;
+export declare const UUID_TYPES: ReadonlySet<string>;
+export declare const JSON_TYPES: ReadonlySet<string>;
+/** The timestamps that keep their offset, or an instant read with one. */
+export declare const TIMESTAMP_TZ_TYPES: ReadonlySet<string>;
+/** An instant the database shows in the session's zone, as MySQL's TIMESTAMP. */
+export declare const TIMESTAMP_LTZ_TYPES: ReadonlySet<string>;
+export declare const MONEY_TYPES: ReadonlySet<string>;
+/** PostgreSQL's bit strings, which its drivers read as text such as 1010. */
+export declare const POSTGRES_BIT_TYPES: ReadonlySet<string>;
+export declare const POSTGRES_TIME_TZ_TYPES: ReadonlySet<string>;
+/** PostgreSQL's system identifiers: xid8 is 64 bits, the others 32. */
+export declare const POSTGRES_OBJECT_ID_TYPES: ReadonlySet<string>;
+export declare const POSTGRES_SERIAL_TYPES: ReadonlySet<string>;
+/** The character types a length argument bounds, in characters or bytes. */
+export declare const CHARACTER_TYPES: ReadonlySet<string>;
+/**
+ * What a column's type holds on a database, read by type name before the
+ * vendor lists, which only file each name under one of eleven categories.
+ */
+export declare function getColumnType(dataType: string, database: number): ColumnType;
+/** MySQL and MariaDB: whether UNSIGNED, ZEROFILL or SERIAL makes a type unsigned. */
+export declare function isUnsigned(dataType: string, database: number): boolean;
+/**
+ * An ENUM's or SET's members, each read as MySQL reads a string literal in
+ * either quote; null where the list holds anything else or nothing.
+ */
+export declare function enumMembers(dataType: string): string[] | null;
+/** A PostgreSQL array's element type and its number of dimensions. */
+export declare function splitPostgresArray(dataType: string, database: number): [element: string, depth: number];
+/** A type's first argument list when every argument is a number. */
+export declare function typeArguments(dataType: string): number[];
+export declare function isMySQLFamily(database: number): boolean;
+/**
+ * The scalar a type's base name gives on a database at the width the name
+ * declares, by the rules by name and then by the category primitiveOf files
+ * the type under; getColumnType widens what Oracle, Snowflake and SQLite store.
+ */
+export declare function columnScalar(element: string, base: string, args: number[], database: number, isUnsigned: boolean, primitiveOf?: (dataType: string, database: number) => PrimitiveType): ColumnScalar;
+//# sourceMappingURL=columnTypes.d.ts.map

package/dist/utils/generator-code/doctrine.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+export declare function createCode(state: RootState): string;
+/** One table's entity under the header and the use statements it needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+//# sourceMappingURL=doctrine.d.ts.map

package/dist/utils/generator-code/doctrineReservedWords.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Every word DBAL 4 lists as reserved on MySQL, MariaDB, PostgreSQL, SQL
+ * Server, Oracle or SQLite, in lower case: Doctrine quotes such a name in the
+ * DDL it writes but in a query only when the mapping marks it with backticks.
+ */
+export declare const DOCTRINE_RESERVED_WORDS: ReadonlySet<string>;
+//# sourceMappingURL=doctrineReservedWords.d.ts.map

package/dist/utils/generator-code/graphql.d.ts

@@ -2,4 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * The name before a last word id, in any case, the separator before it
+ * dropped, words split as isSingleWord splits them; null where id is not a
+ * word of its own, or is the only one.
+ */
+export declare function stripIdWord(name: string): string | null;
 //# sourceMappingURL=graphql.d.ts.map

package/dist/utils/generator-code/heck.d.ts

@@ -0,0 +1,5 @@
+/** heck's to_snake_case, which SeaORM's derive macros name columns by. */
+export declare function toSnakeCase(value: string): string;
+/** heck's to_upper_camel_case, which SeaORM's derive macros name variants by. */
+export declare function toUpperCamelCase(value: string): string;
+//# sourceMappingURL=heck.d.ts.map

package/dist/utils/generator-code/java.d.ts

@@ -1,5 +1,33 @@
 import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
+/**
+ * A column element's type on the JVM, named as Java writes it but for bytes,
+ * which Java, Kotlin and Scala each spell their own way.
+ */
+export type JvmType = 'BigDecimal' | 'Boolean' | 'Byte' | 'bytes' | 'Double' | 'Duration' | 'Float' | 'Integer' | 'LocalDate' | 'LocalDateTime' | 'LocalTime' | 'Long' | 'OffsetDateTime' | 'OffsetTime' | 'Short' | 'String' | 'UUID';
+export type JvmColumnType = {
+    type: JvmType;
+    /** PostgreSQL array dimensions, each one array or list level around the type. */
+    arrayDepth: number;
+};
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** The JVM type of a column on a database, from the shared column classifier. */
+export declare function getJvmType(dataType: string, database: number): JvmColumnType;
+/**
+ * A field name, with an underscore after a reserved word and after a name
+ * that breaks the class Lombok completes.
+ */
+export declare function toJavaFieldName(name: string): string;
+export declare function toJavaClassName(name: string): string;
+/**
+ * javac reads a backslash and u as a Unicode escape even in a comment, where
+ * a bad one fails the compile; an even run of backslashes starts none.
+ */
+export declare function escapeUnicodeEscapes(value: string): string;
+/**
+ * A comment as line comments, one for each of its lines, its blank first and
+ * last lines dropped; nothing for a comment that is only whitespace.
+ */
+export declare function formatLineComment(buffer: string[], indent: string, comment: string, escape?: (line: string) => string): void;
 //# sourceMappingURL=java.d.ts.map

package/dist/utils/generator-code/jsonSchema.d.ts

@@ -0,0 +1,50 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { JsonShape } from './jsonShape';
+export type JsonScalar = string | number | boolean | null;
+/**
+ * An object as a Map, which keeps every key where it was set, __proto__ and
+ * integer-like keys too, where a plain object loses or reorders them.
+ */
+export type JsonObject = Map<string, JsonValue>;
+export type JsonValue = JsonScalar | JsonScalar[] | JsonObject;
+export declare const DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/**
+ * A time of day with no offset, as z.iso.time() takes it, written with [0-9]
+ * since \d matches any script's decimal digits in a Python or .NET validator.
+ */
+export declare const TIME_PATTERN = "^(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?)?$";
+/**
+ * A date and time with no offset; the Z a driver's Date.prototype.toJSON adds
+ * passes after seconds, as z.iso.datetime({ local: true }) lets it.
+ */
+export declare const NAIVE_DATE_TIME_PATTERN = "^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])T(?:[01][0-9]|2[0-3]):[0-5][0-9](?::[0-5][0-9](?:\\.[0-9]+)?Z?)?$";
+/** Every table's row schema under $defs, keyed by the cased table name. */
+export declare function createCode(state: RootState): string;
+/** One table's row schema standing alone, its name never numbered. */
+export declare function createTableCode(state: RootState, table: Table): string;
+/**
+ * Each table's key: a name met again is numbered from 2, past every name a
+ * table takes as is, so a table named user2 keeps User2 beside two users.
+ */
+export declare function toDefinitionKeys(names: string[]): string[];
+/** The schema of one value of a column, NOT NULL, with no description. */
+export declare function toValueSchema(shape: JsonShape): JsonObject;
+/**
+ * A schema that takes null too: null joins its type, and its enum, which
+ * refuses a value it does not list; a schema with no type takes null already.
+ */
+export declare function withNull(schema: JsonObject): JsonObject;
+/**
+ * JSON as Prettier writes it: two spaces a level, an object one key a line,
+ * and an array on one line while that line fits in 80 columns, its comma
+ * counted only where another key follows, else one item a line.
+ */
+export declare function formatJson(object: JsonObject, indent?: string): string;
+/**
+ * Columns a string takes on a line, a code point at a time as Prettier counts:
+ * two for a wide or fullwidth one or an emoji that takes a skin tone, none for
+ * a control, a combining mark U+0300-U+036F or a variation selector, else one.
+ */
+export declare function textWidth(text: string): number;
+//# sourceMappingURL=jsonSchema.d.ts.map

package/dist/utils/generator-code/jsonShape.d.ts

@@ -0,0 +1,37 @@
+import { Column } from '../../internal-types';
+/**
+ * What one value of a column looks like in JSON, as an API sends a row: dates
+ * and times as ISO text, a decimal as a string, binary as base64.
+ */
+export type JsonShapeKind = 'boolean' | 'integer' | 'number' | 'string' | 'uuid' | 'guid' | 'date' | 'time' | 'naiveDateTime' | 'offsetDateTime' | 'base64' | 'json' | 'enum' | 'ipv4' | 'ipv6' | 'null';
+export type JsonShape = {
+    kind: JsonShapeKind;
+    /** An integer's least value; null where the column sets none. */
+    minimum: number | null;
+    /**
+     * An integer's greatest value; null for a 64-bit one, whose range no JSON
+     * number holds exactly, so each language writes its own safe bound or none.
+     */
+    maximum: number | null;
+    /** A character type's declared length, which a shorter value meets too. */
+    maxLength: number | null;
+    /** An ENUM's members as a row holds them, each once, in the type's order. */
+    members: string[];
+    /** A PostgreSQL array's dimensions, each one a JSON array around the last. */
+    arrayDepth: number;
+};
+/**
+ * A column's value in the JSON shape, the one reading the Zod, JSON Schema
+ * and TypeScript generators share, so their types agree column by column.
+ */
+export declare function getJsonShape(dataType: string, database: number): JsonShape;
+/** A primary key takes no NULL, its NN flag set or not, as in every generator. */
+export declare function isNullableColumn(column: Column): boolean;
+/**
+ * A name TypeScript refuses for an interface or a type alias gets an
+ * underscore after it; any other name is written as the name cases give it.
+ */
+export declare function toTypeScriptTypeName(name: string): string;
+/** A key bare where TypeScript reads an identifier, else a string literal. */
+export declare function toTypeScriptPropertyKey(name: string): string;
+//# sourceMappingURL=jsonShape.d.ts.map

package/dist/utils/generator-code/kotlin.d.ts

@@ -2,4 +2,5 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function toKotlinName(name: string): string;
 //# sourceMappingURL=kotlin.d.ts.map

package/dist/utils/generator-code/mermaid.d.ts

@@ -0,0 +1,5 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=mermaid.d.ts.map

package/dist/utils/generator-code/php.d.ts

@@ -0,0 +1,28 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * PHP takes declare(strict_types=1) only as the first statement, so the text
+ * opens on the tag with nothing before it, not even the blank line the other
+ * languages open with.
+ */
+export declare const PHP_HEADER: readonly string[];
+export declare const INDENT = "    ";
+export declare function createCode(state: RootState): string;
+/** One table's class under the header, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A PostgreSQL array type, which pdo_pgsql reads as a text literal such as {1,2}. */
+export declare function isPostgresArray(dataType: string, database: number): boolean;
+/**
+ * A name PHP refuses for a class, in any letter case, gets an underscore
+ * after it, as nikic/PHP-Parser names its List_ and Match_ nodes.
+ */
+export declare function toClassName(name: string): string;
+/**
+ * A comment as a doc block, one line or several: a line comment would end at
+ * a ?> in the text and leave PHP, where a block runs on to its close, which a
+ * star and a slash in the text would write early.
+ */
+export declare function formatDocComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=php.d.ts.map

package/dist/utils/generator-code/rust.d.ts

@@ -0,0 +1,13 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare const INDENT = "    ";
+/** Every keyword of edition 2015 to 2024 a raw identifier takes. */
+export declare const RUST_KEYWORDS: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A keyword as a raw identifier, or with an underscore after it where rustc takes none. */
+export declare function toRustIdentifier(name: string): string;
+export declare function toStructName(name: string): string;
+/** A comment as line comments, its bidirectional controls written as escapes. */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=rust.d.ts.map

package/dist/utils/generator-code/rustTypes.d.ts

@@ -0,0 +1,44 @@
+/** The Rust value a column's element holds, which each generator spells its own way. */
+export type RustScalar = 'bool' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64' | 'decimal' | 'string' | 'bytes' | 'uuid' | 'json' | 'date' | 'time' | 'dateTime' | 'dateTimeUtc' | 'dateTimeOffset';
+/**
+ * Each scalar by its full path, so a struct compiles with no use statement
+ * and beside a struct of any of these last names.
+ */
+export declare const RUST_SCALAR_PATHS: Readonly<Record<RustScalar, string>>;
+export type RustColumnType = {
+    scalar: RustScalar;
+    /** The field type with one Vec a PostgreSQL array dimension, by full paths. */
+    rust: string;
+    /**
+     * The element's type name, lower case, its arguments gone, and on MySQL and
+     * MariaDB its UNSIGNED and ZEROFILL too.
+     */
+    base: string;
+    /** The element's arguments when all are numbers: numeric(10,2) gives [10, 2]. */
+    args: number[];
+    arrayDepth: number;
+    /** MySQL and MariaDB: UNSIGNED, ZEROFILL or SERIAL in the type. */
+    isUnsigned: boolean;
+    isFloat: boolean;
+    /**
+     * PostgreSQL alone: the type sqlx reads the column through, cast, where it
+     * reads the column's own type into no Rust type here; null elsewhere.
+     */
+    selectAs: string | null;
+    /**
+     * The element as an entity declares it: a PostgreSQL array of more than one
+     * dimension, which neither sqlx nor SeaORM decodes, is a string read as text.
+     */
+    entityScalar: RustScalar;
+};
+/** PostgreSQL's character types, which sqlx reads into a String as they are. */
+export declare const POSTGRES_CHARACTER_TYPES: ReadonlySet<string>;
+/**
+ * The shared column classifier with the choices sqlx makes for Rust on top: an
+ * Oracle, Snowflake or SQLite integer keeps the width its name declares, and a
+ * MySQL SIGNED stays in the name, which keeps it from every rule by name.
+ */
+export declare function getRustColumnType(dataType: string, database: number): RustColumnType;
+/** A type inside one Vec per dimension. */
+export declare function wrapVec(type: string, depth: number): string;
+//# sourceMappingURL=rustTypes.d.ts.map

package/dist/utils/generator-code/scala.d.ts

@@ -2,4 +2,5 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function toScalaName(name: string): string;
 //# sourceMappingURL=scala.d.ts.map

package/dist/utils/generator-code/seaorm.d.ts

@@ -0,0 +1,22 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+type EntityColumnType = {
+    type: string;
+    columnType: string | null;
+    selectAs: string | null;
+    saveAs: string | null;
+    isFloat: boolean;
+};
+export declare function createCode(state: RootState): string;
+/** One table's entity as its module file holds it, named in the whole document. */
+export declare function createTableCode(state: RootState, table: Table): string;
+/** The column name DeriveEntityModel gives a field it reads without column_name. */
+export declare function derivedColumnName(field: string): string;
+/** UpperCamelCase applied until it stops changing: aBC gives ABc, then ABc. */
+export declare function stableUpperCamelCase(value: string): string;
+/** A Rust string literal rustc takes for any text. */
+export declare function rustString(value: string): string;
+/** The field type, column_type, select_as and save_as an entity writes. */
+export declare function getEntityColumnType(dataType: string, database: number): EntityColumnType;
+export {};
+//# sourceMappingURL=seaorm.d.ts.map

package/dist/utils/generator-code/swift.d.ts

@@ -0,0 +1,44 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * Date, Data, Decimal and UUID need Foundation, and an unused import draws no
+ * warning, so the text and the one-table view open on it whatever they hold.
+ */
+export declare const SWIFT_HEADER: readonly string[];
+export declare const INDENT = "    ";
+/**
+ * A nonisolated struct keeps its conformances usable off the main actor in a
+ * module whose default isolation is MainActor, as new Xcode app targets set.
+ */
+export declare const STRUCT_HEAD = "nonisolated struct";
+export declare const CONFORMANCES = "Codable, Hashable, Sendable";
+/** The words the Swift lexer reserves, which a name takes only in backticks. */
+export declare const SWIFT_KEYWORDS: ReadonlySet<string>;
+/**
+ * The types and protocols the output writes unqualified: a struct of one of
+ * these names breaks the conformances or silently retypes every such field.
+ */
+export declare const TYPE_NAMES: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+/** One table's struct under the import, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A column's Swift type, one array a PostgreSQL dimension, without its optional. */
+export declare function swiftType(dataType: string, database: number): string;
+/** A type name gets an underscore after it, and a keyword backticks. */
+export declare function toStructName(name: string): string;
+/** A property's coding key, an underscore after a name the keys reserve. */
+export declare function toPropertyKey(name: string): string;
+export declare function toPropertyName(key: string): string;
+/**
+ * A Swift string literal: a quote and a backslash, which would also open an
+ * interpolation, get a backslash, and every C0 control and DEL an escape.
+ */
+export declare function toStringLiteral(value: string): string;
+/**
+ * A comment as documentation lines, split at every line terminator, since a
+ * lone CR ends a line comment; a NUL, which Swift warns about, is an escape.
+ */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=swift.d.ts.map

package/dist/utils/generator-code/utils.d.ts

@@ -15,7 +15,26 @@ export interface FormatRelationOptions {
 }
 export declare const hasOneRelationship: (value: number) => boolean;
 export declare const hasNRelationship: (value: number) => boolean;
+/** The ECMAScript line terminators, CR LF one of them, where a line comment ends. */
+export declare const LINE_TERMINATOR: RegExp;
 export declare function getPrimitiveType(dataType: string, database: number): PrimitiveType;
+/** The vendor list entry a data type names, the longest that prefixes it. */
+export declare function findDataTypeHint(dataType: string, database: number): DataTypeHint | undefined;
+/**
+ * The precision and scale of an Oracle or Snowflake NUMBER with a scale, which
+ * the vendor lists file under long with every other NUMBER; a star is 38.
+ */
+export declare function fractionalNumber(dataType: string, database: number): [precision: number, scale: number] | null;
+/** The type name in lower case, with its argument lists and extra spaces gone. */
+export declare function baseTypeName(dataType: string): string;
+/** A text split into its lines at every ECMAScript line terminator. */
+export declare function splitLines(value: string): string[];
+/**
+ * A line comment's text with a backslash before its at sign where it opens with
+ * one and ts-, after any white space and in any case, so the line stays legible
+ * and TypeScript reads no directive in it, which would hide or expect an error.
+ */
+export declare function escapeTypeScriptDirective(line: string): string;
 export declare function getDataTypeHints(database: number): DataTypeHint[];
 export declare function getNameCase(name: string, nameCase: number): string;
 export type ReferentialActionEntry = {

package/dist/utils/generator-code/zod.d.ts

@@ -0,0 +1,25 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { JsonShape } from './jsonShape';
+import { FormatTableOptions } from './utils';
+/** Every table's row schema and its inferred type, under one import line. */
+export declare function createCode(state: RootState): string;
+/** One table under the import line, so its file compiles on its own. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A value's Zod schema, one z.array around it for each array dimension. */
+export declare function toZodSchema(shape: JsonShape): string;
+/**
+ * A name a type alias may not take, z included, gets an underscore after it;
+ * any other name, one that is no identifier or a repeated one included, is
+ * written as is.
+ */
+export declare function toZodTypeName(name: string): string;
+/**
+ * A property key as an object literal writes it; __proto__ is computed, since
+ * written plainly or quoted it would set the object's prototype instead.
+ */
+export declare function toZodPropertyKey(name: string): string;
+/** A comment as line comments, one for each of its lines, none a TypeScript directive. */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=zod.d.ts.map

package/dist/utils/globalEventObservable.d.ts

@@ -11,12 +11,21 @@ export declare const animationFrames$: Observable<{
     elapsed: number;
 }>;
 export declare const moveStart$: Observable<MouseEvent | TouchEvent>;
+/**
+ * The middle presses a scene pan stopped below a target, read off the forward
+ * each one hands the move stream: a listener above the stage container that
+ * closes on any press hears a middle press there only this way.
+ *
+ * @example
+ * addUnsubscribe(middlePanPress$(root).subscribe(handleOutsidePress));
+ */
+export declare function middlePanPress$(target: EventTarget): Observable<MouseEvent>;
 /**
  * A gesture also ends wherever the browser takes the pointer away: a native
  * drag swallows the rest of the stream, a cancelled pointer never lifts, and a
  * blurred window never sees the mouseup, each leaving drag$ subscribed.
  */
-export declare const moveEnd$: Observable<MouseEvent | TouchEvent | DragEvent | PointerEvent | FocusEvent>;
+export declare const moveEnd$: Observable<MouseEvent | TouchEvent | FocusEvent | PointerEvent | DragEvent>;
 export type DragMove = {
     movementX: number;
     movementY: number;

package/dist/utils/highlightWords.d.ts

@@ -0,0 +1,29 @@
+import { TextRange } from './find-replace';
+/** A stretch of the text, lit or plain; the chunks of one text run end to end. */
+type Chunk = TextRange & {
+    highlight: boolean;
+};
+export type FindChunksArgs = {
+    searchWords: string[];
+    textToHighlight: string;
+    /** Whether a word lights only its own letter case; false when left out. */
+    caseSensitive?: boolean;
+};
+export type FindAllArgs = FindChunksArgs & {
+    /** Where the text holds the words, findChunks when left out; the ranges may overlap and come in any order. */
+    findChunks?: (args: FindChunksArgs) => TextRange[];
+};
+/**
+ * Where the text holds each word, word by word and left to right, a match
+ * starting only past the end of that word's last one: a word is read as typed,
+ * never as a regular expression, and an empty one holds nothing.
+ */
+export declare function findChunks({ searchWords, textToHighlight, caseSensitive, }: FindChunksArgs): TextRange[];
+/**
+ * The whole text as chunks: one lit chunk for each run of matches that overlap
+ * or touch, so two words side by side light as one, and plain chunks between
+ * them. An empty text has none.
+ */
+export declare function findAll({ searchWords, textToHighlight, caseSensitive, findChunks: find, }: FindAllArgs): Chunk[];
+export {};
+//# sourceMappingURL=highlightWords.d.ts.map

package/dist/utils/index.d.ts

@@ -1,8 +1,7 @@
-import { EntityMeta, Memo, Point, Settings, Table } from '../internal-types';
+import { Memo, Point, Settings, Table } from '../internal-types';
 export declare const nextZIndex: (tables: Table[], memos: Memo[]) => number;
 export declare function nextPoint(settings: Settings, tables: Table[], memos: Memo[]): Point;
 export declare const toList: <T>(ids: string[], entities: Record<string, T>) => Array<T>;
-export declare function getDefaultEntityMeta(): EntityMeta;
 export declare function safeRange(a: number, b: number): number[];
 export declare function pascalCase(value?: string): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/keyboard-shortcut/bindKeys.d.ts

@@ -0,0 +1,9 @@
+/** A handler per shortcut, whose presses of a sequence a space separates. */
+export type KeyBindingHandlers = Record<string, (event: KeyboardEvent) => void>;
+/**
+ * Calls each shortcut's handler on the target's keydown that completes it and
+ * returns the unbinding. A modifier's own keydown keeps a sequence going; any
+ * other miss, or a second with no keydown, sends it back to its first press.
+ */
+export declare function bindKeys(target: EventTarget, handlers: KeyBindingHandlers): () => void;
+//# sourceMappingURL=bindKeys.d.ts.map

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -1,5 +1,6 @@
 import { ValuesType } from '../../internal-types';
 import { KeyBindingPress } from './utils';
+export { bindKeys, type KeyBindingHandlers } from './bindKeys';
 export type ShortcutOption = {
     shortcut: string;
     preventDefault?: boolean;
@@ -17,6 +18,7 @@ export declare const KeyBindingName: {
     readonly addMemo: "addMemo";
     readonly removeTable: "removeTable";
     readonly removeColumn: "removeColumn";
+    readonly removeSelection: "removeSelection";
     readonly primaryKey: "primaryKey";
     readonly selectAllTable: "selectAllTable";
     readonly selectAllColumn: "selectAllColumn";
@@ -33,13 +35,18 @@ export declare const KeyBindingName: {
     readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "findReplace" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
+export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "findReplace" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
+/**
+ * The chords a press inside a floating panel still carries to the editor:
+ * Find and Replace's own, search, the document's undo and redo, and the zoom.
+ */
+export declare const PANEL_PASSING_BINDINGS: ReadonlyArray<KeyBindingName>;
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
 export declare const createKeyBindingMap: () => KeyBindingMap;
 /**
- * Whether the press is one of the chords given, read the way tinykeys reads a
- * binding: the key by its code or its value, every modifier named held down and
- * no other. A sequence of presses never matches a single one.
+ * Whether the press is one of the chords given, matched as bindKeys matches a
+ * press, so a panel reads a binding as the editor root does. A sequence of
+ * presses never matches a single one.
  */
 export declare function matchesShortcut(event: KeyboardEvent, options: ReadonlyArray<ShortcutOption>): boolean;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];

package/dist/utils/keyboard-shortcut/utils.d.ts

@@ -1,3 +1,24 @@
+import { ValuesType } from '../../internal-types';
 export type KeyBindingPress = [string[], string];
+/** The modifiers that change what a press means; AltGraph is read through them. */
+export declare const ModifierKey: {
+    readonly Shift: "Shift";
+    readonly Meta: "Meta";
+    readonly Alt: "Alt";
+    readonly Control: "Control";
+};
+export type ModifierKey = ValuesType<typeof ModifierKey>;
 export declare function parseKeybinding(str: string): KeyBindingPress[];
+/**
+ * Whether the modifier is held, AltGraph counting as the ones it aliases. A
+ * keydown Chrome sends for a function key may lack getModifierState, and then
+ * holds nothing.
+ */
+export declare function isModifierHeld(event: KeyboardEvent, mod: string): boolean;
+/**
+ * Whether the event is the press: the key by its value in any case or by its
+ * code, every modifier the press names held, and no other modifier unless it
+ * is the key itself.
+ */
+export declare function matchesPress(event: KeyboardEvent, [mods, key]: KeyBindingPress): boolean;
 //# sourceMappingURL=utils.d.ts.map