@dbml/parse 11.0.0-alpha.2 → 11.0.0-alpha.4

package/dist/src/compiler/index.d.ts

@@ -9,10 +9,6 @@ import { NodeSymbolIdGenerator, SymbolFactory } from '../core/types/symbol';
 import { DBMLCodeActionProvider, DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
 import { DbmlProjectLayout } from './projectLayout';
 import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString } from './queries/utils';
-/**
- * Grammar switches a dialect asks for, gathered in one place so the Compiler does not grow a
- * parameter per stage. Every switch inside is off by default, so DBML is exactly what it was.
- */
 export interface DialectOptions {
     lexer?: LexerOptions;
     parser?: ParserOptions;
@@ -28,12 +24,6 @@ export default class Compiler {
     readonly explicitModules: GlobalModule[] | undefined;
     private readonly explicitDialect;
     readonly dialect: DialectOptions;
-    /**
-     * @param layout the structure of the DbmlProject
-     * @param modules the element vocabulary for every file. When omitted, each file uses the
-     *   modules of its own kind (DBML or architecture).
-     * @param dialect grammar switches for every file. When omitted, each file gets its kind's switches.
-     */
     constructor(layout: DbmlProjectLayout, modules?: GlobalModule[], dialect?: DialectOptions);
     getSource(filepath: Filepath): string | undefined;
     lexerOptions(): LexerOptions;

package/dist/src/compiler/queries/transform/renameElement.d.ts

@@ -1,13 +1,8 @@
 import { Filepath } from '../../../core/types/filepath';
 import { default as Compiler } from '../../index';
 /**
- * Renames an architecture element (node, group or note box) in `filepath`.
- *
- * With an `as` alias, links, groups and metadata name the element by its alias, so only the
- * name changes. Without one the name is the handle, so every link endpoint, group member and
+ * With an `as` alias only the name changes. Without one, every link endpoint, group member and
  * metadata target in the same file that names it is renamed too.
- *
- * Returns a map of absolute file paths to new source content. An empty map indicates a no-op
- * (lookup miss or name collision).
+ * An empty map means no change (lookup miss or name collision).
  */
 export declare function renameElement(this: Compiler, filepath: Filepath, oldHandle: string, newName: string): Map<string, string>;

package/dist/src/compiler/queries/transform/utils/arch.d.ts

@@ -1,6 +1,17 @@
 import { Filepath } from '../../../../core/types/filepath';
-import { ElementDeclarationNode } from '../../../../core/types/nodes';
+import { AttributeNode, ElementDeclarationNode, ListExpressionNode } from '../../../../core/types/nodes';
 import { default as Compiler } from '../../../index';
+import { TextEdit } from '../applyTextEdits';
 export declare function archDeclarations(compiler: Compiler, filepath: Filepath): ElementDeclarationNode[];
 export declare function findArchElement(compiler: Compiler, filepath: Filepath, handle: string): ElementDeclarationNode | undefined;
-export declare function findArchLink(compiler: Compiler, filepath: Filepath, from: string, to: string): ElementDeclarationNode | undefined;
+export type ArchLinkDefinition = {
+    kind: 'standalone';
+    declaration: ElementDeclarationNode;
+} | {
+    kind: 'inline';
+    element: ElementDeclarationNode;
+    attribute: AttributeNode;
+    op: string;
+};
+export declare function findArchLink(compiler: Compiler, filepath: Filepath, from: string, to: string): ArchLinkDefinition | undefined;
+export declare function removeAttributeEdit(list: ListExpressionNode, attribute: AttributeNode, source: string): TextEdit;

package/dist/src/core/arch/icons.d.ts

@@ -1,5 +1,4 @@
 export declare const ICON_NAMES: string[];
-/** what people actually type; an alias costs one line and saves a diagnostic */
 export declare const ICON_ALIAS: Record<string, string>;
 export declare const resolveIcon: (name: string) => string;
 export declare const isIconName: (name: string) => boolean;

package/dist/src/core/arch/read.d.ts

@@ -1,14 +1,16 @@
-import { ElementDeclarationNode, ListExpressionNode, SyntaxNode } from '../types/nodes';
+import { AttributeNode, ElementDeclarationNode, ListExpressionNode, SyntaxNode } from '../types/nodes';
 import { ArchSettingValue, ArchSettings } from '../types/schemaJson';
-export type ArchSort = 'node' | 'group' | 'note' | 'kind' | 'link' | 'metadata' | 'project';
+export type ArchSort = 'node' | 'group' | 'kind' | 'link' | 'metadata' | 'project';
 export declare const declarationWord: (node: ElementDeclarationNode) => string | undefined;
 export declare function isTopLevel(node: SyntaxNode): node is ElementDeclarationNode;
 export declare function archSort(node: SyntaxNode): ArchSort | undefined;
+export declare const isTopLevelNote: (node: SyntaxNode) => boolean;
 export declare function topLevelDeclaration(node: SyntaxNode): ElementDeclarationNode | undefined;
 export declare function nameOf(node?: SyntaxNode): string | undefined;
 export declare const handleOf: (node: ElementDeclarationNode) => string | undefined;
 export declare function numberOf(node?: SyntaxNode): number | null;
 export declare function valueOf(node: SyntaxNode): ArchSettingValue | undefined;
+export declare const isInlineLinkKey: (key: string) => boolean;
 export declare function settingsOf(list?: ListExpressionNode): ArchSettings;
 export declare function bodyOf(node: ElementDeclarationNode): SyntaxNode[];
 export interface Row {
@@ -30,6 +32,13 @@ export interface LinkParts {
     infix: Infix;
 }
 export declare function linkPartsOf(declaration: ElementDeclarationNode): LinkParts | undefined;
+export declare function isInlineLink(attribute: AttributeNode): boolean;
+export declare function inlineLinksOf(declaration: ElementDeclarationNode): AttributeNode[];
+export interface InlineLink {
+    op: string;
+    target: SyntaxNode;
+}
+export declare function inlineLinkOf(attribute: AttributeNode): InlineLink | undefined;
 export interface Property {
     key: string;
     value: ArchSettingValue | undefined;
@@ -37,7 +46,6 @@ export interface Property {
 export declare function propertyOf(node: SyntaxNode): Property | undefined;
 export declare function noteDeclarationOf(declaration: ElementDeclarationNode): ElementDeclarationNode | undefined;
 export declare function noteTextOf(note: ElementDeclarationNode): string;
-export declare function noteBoxTextOf(declaration: ElementDeclarationNode): string;
 export declare const IMAGE_URL: RegExp;
 export declare const IMAGE_REFUSED = "A picture must be an https: URL or a data:image/ URI.";
 export interface BodyRead {

package/dist/src/core/global_modules/arch/interpret.d.ts

@@ -1,11 +1,11 @@
 import { default as Compiler } from '../../../compiler';
 import { Filepath } from '../../types/filepath';
 import { default as Report } from '../../types/report';
-import { ArchSettings, Group, Kind, Link, Node, NoteBox } from '../../types/schemaJson';
+import { ArchSettings, Group, Kind, Link, Node } from '../../types/schemaJson';
 import { ElementSymbol, KindSymbol } from '../../types/symbol';
 import { ArchMetadataElementMetadata, LinkMetadata } from '../../types/symbol/metadata';
-export declare function interpretElement(compiler: Compiler, symbol: ElementSymbol, filepath: Filepath): Report<Node | Group | NoteBox | undefined>;
+export declare function interpretElement(compiler: Compiler, symbol: ElementSymbol, filepath: Filepath): Report<Node | Group | undefined>;
 export declare function interpretKind(symbol: KindSymbol): Report<Kind | undefined>;
 export declare function builtinKinds(): Kind[];
-export declare function interpretLink(compiler: Compiler, metadata: LinkMetadata): Report<Link | undefined>;
+export declare function interpretLink(compiler: Compiler, metadata: LinkMetadata, filepath: Filepath): Report<Link | undefined>;
 export declare function interpretArchMetadata(metadata: ArchMetadataElementMetadata): Report<ArchSettings>;

package/dist/src/core/global_modules/arch/utils.d.ts

@@ -4,4 +4,4 @@ import { NodeSymbol, SymbolKind } from '../../types/symbol';
 export declare function lookupVisible(compiler: Compiler, filepath: Filepath, kind: SymbolKind, name: string): NodeSymbol | undefined;
 export declare function visibleKinds(compiler: Compiler, filepath: Filepath): Map<string, NodeSymbol>;
 export declare function resolveRole(compiler: Compiler, filepath: Filepath, word: string): string | undefined;
-export declare function originalHandle(symbol: NodeSymbol): string | undefined;
+export declare function originalHandle(compiler: Compiler, symbol: NodeSymbol, filepath: Filepath): string | undefined;

package/dist/src/core/global_modules/index.d.ts

@@ -7,19 +7,6 @@ import { NodeMetadata } from '../types/symbol/metadata';
 import { SchemaElement } from '../types/schemaJson';
 import { NodeSymbol } from '../types/symbol';
 import { GlobalModule } from './types';
-/**
- * The DBML vocabulary: the modules a Compiler uses when nobody says otherwise.
- *
- * The dispatcher tries each in order until one claims the node, so order is meaningful. Each
- * time you add a new DBML element, register its module here.
- *
- * A Compiler may also be built with a different list (see `Compiler`'s second argument). The
- * lexer and the parser do not know this vocabulary at all: `parser.ts` has one generic
- * `elementDeclaration()` and never mentions `ElementKind`, so another dialect is a different
- * array, not a different grammar. Pass a different list and the same front end binds a
- * different language, which is how the architecture dialect reuses all of this without forking
- * it or widening DBML's own vocabulary by a single word.
- */
 export declare const dbmlModules: GlobalModule[];
 export declare const archModules: GlobalModule[];
 export declare function nodeSymbol(this: Compiler, node: SyntaxNode): Report<NodeSymbol> | Report<Unhandled>;

package/dist/src/core/lexer/lexer.d.ts

@@ -1,17 +1,7 @@
 import { Filepath } from '../types/filepath';
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
-/**
- * Grammar switches the lexer offers a dialect. Off by default, so DBML is untouched.
- */
 export interface LexerOptions {
-    /**
-     * Read a `---` fenced block at the very top of a file as one trivia token.
-     *
-     * It is Markdown's convention and people expect it for file-level metadata. DBML has no use
-     * for it, because `Project { ... }` already carries that and its interpreter files any
-     * unrecognised field as a free-form property. A dialect that wants both says so here.
-     */
     allowFrontMatter?: boolean;
 }
 export default class Lexer {
@@ -23,13 +13,6 @@ export default class Lexer {
     private errors;
     private readonly options;
     constructor(text: string, filepath: Filepath, options?: LexerOptions);
-    /**
-     * Only at offset zero, and only up to the closing fence.
-     *
-     * It is consumed character by character like everything else, so `line` and `column` keep
-     * counting and every token after it still reports where it really is. Lifting the block out
-     * of the text instead would shift every diagnostic in the file by however many lines it had.
-     */
     private scanFrontMatter;
     private isAtEnd;
     private advance;

package/dist/src/core/parser/parser.d.ts

@@ -2,20 +2,7 @@ import { Filepath } from '../types/filepath';
 import { ProgramNode, SyntaxNodeIdGenerator } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { SyntaxToken } from '../types/tokens';
-/**
- * Grammar switches a dialect may ask for. Every one of these is off by default, so the DBML
- * grammar is exactly what it was; a dialect that wants a different shape says so, and the
- * difference is one flag rather than a forked parser.
- */
 export interface ParserOptions {
-    /**
-     * Allow an element declaration with no body: `Database mongo1` as a complete statement.
-     *
-     * DBML has nothing that reads that way, because every DBML element carries something: a Table
-     * has columns, a Ref has endpoints. An architecture file is the opposite, mostly bare nouns
-     * with the occasional body, and writing `Database mongo1 { }` on every line to satisfy a
-     * grammar rule that exists for a different language would be the tail wagging the dog.
-     */
     allowBodylessElement?: boolean;
 }
 export default class Parser {

package/dist/src/core/types/schemaJson/types.d.ts

@@ -29,7 +29,6 @@ export interface DatabaseExternals {
     notes: ElementRef[];
     nodes?: ElementRef[];
     groups?: ElementRef[];
-    noteBoxes?: ElementRef[];
     kinds?: ElementRef[];
 }
 /**
@@ -76,7 +75,6 @@ export interface Database {
     token?: TokenPosition;
     nodes?: Node[];
     groups?: Group[];
-    noteBoxes?: NoteBox[];
     links?: Link[];
     kinds?: Kind[];
     frontMatter?: Record<string, string>;
@@ -109,12 +107,6 @@ export interface Group {
     } | null;
     token: TokenPosition;
 }
-export interface NoteBox {
-    name: string;
-    alias: string | null;
-    content: string;
-    token: TokenPosition;
-}
 export type LinkOp = '>' | '<' | '<>' | '-';
 export interface Link {
     from: string;
@@ -359,4 +351,4 @@ export type Project = Record<string, never> | {
     token: TokenPosition;
     [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
 };
-export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues | Node | Group | NoteBox | Link | Kind | ArchSettings;
+export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues | Node | Group | Link | Kind | ArchSettings;

package/dist/src/core/types/symbol/metadata.d.ts

@@ -117,9 +117,10 @@ export declare class MetadataElementMetadata extends NodeMetadata {
     owners(compiler: Compiler): NodeSymbol[];
 }
 export declare class LinkMetadata extends NodeMetadata {
-    declaration: ElementDeclarationNode;
+    declaration: ElementDeclarationNode | AttributeNode;
     readonly kind = MetadataKind.Link;
-    constructor(declaration: ElementDeclarationNode);
+    constructor(declaration: ElementDeclarationNode | AttributeNode);
+    op(): string | undefined;
     endpoints(compiler: Compiler): [NodeSymbol | undefined, NodeSymbol | undefined];
     owners(compiler: Compiler): NodeSymbol[];
 }

package/dist/src/core/types/tokens.d.ts

@@ -25,7 +25,6 @@ export declare enum SyntaxTokenKind {
     COLON = "<colon>",
     SINGLE_LINE_COMMENT = "<single-line-comment>",
     MULTILINE_COMMENT = "<multiline-comment>",
-    /** a `---` fenced block at the very top of a file; only a dialect that asks for it gets one */
     FRONT_MATTER = "<front-matter>",
     WILDCARD = "<wildcard>"
 }

package/dist/src/index.d.ts

@@ -11,7 +11,7 @@ export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from '.
 export { CompileError, CompileErrorCode, } from './core/types/errors';
 export type { Position, } from './core/types';
 export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, normalizeQualifiedName, } from './compiler/index';
-export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, type CustomMetadata, type Node, type Group, type NoteBox, type Link, type LinkOp, type Kind, type KindCategory, type ArchSettings, type ArchSettingValue, } from './core/types/schemaJson';
+export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, type CustomMetadata, type Node, type Group, type Link, type LinkOp, type Kind, type KindCategory, type ArchSettings, type ArchSettingValue, } from './core/types/schemaJson';
 export { type FileKind, ARCH_DIAGRAM_TYPES, isArchDiagramType } from './compiler/queries/files/fileKind';
 export { BUILTIN_KINDS, RESERVED, isReserved, suggestKind, suggestIcon, type KindSpec, } from './core/arch/vocabulary';
 export { ICON_ALIAS, ICON_NAMES, isIconName, resolveIcon, } from './core/arch/icons';
@@ -22,14 +22,6 @@ export type { DepSyncOperation, DepSyncEdge, DepEndpointRef } from './compiler/q
 export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, ArchElementIdentifier, ArchLinkIdentifier, } from './compiler/queries/transform';
 export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
 export * from './compiler/projectLayout/layout';
-/**
- * The dialect seam.
- *
- * A Compiler takes the element vocabulary and the grammar switches it should run with. Pass a
- * different module list and the same lexer, parser, file graph, caching and diagnostics bind a
- * different language. Nothing below this line changes DBML: `dbmlModules` is what a Compiler
- * uses when nobody says otherwise, and every switch in `ParserOptions` is off by default.
- */
 export { dbmlModules } from './core/global_modules';
 export type { GlobalModule } from './core/global_modules/types';
 export type { ParserOptions } from './core/parser/parser';

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "11.0.0-alpha.2",
+  "version": "11.0.0-alpha.4",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -51,5 +51,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "75a0e5bf55149fef937ec7d02e48c170421229ff"
+  "gitHead": "40f71a2018dd2a5a9452cd4ba680ef08289fae3a"
 }