@dbml/parse 10.4.0-metadata-ref-type.0 → 10.4.0-metadata-type.0

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

@@ -50,26 +50,7 @@ export default class Compiler {
     symbolMetadata: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/symbol').NodeMetadata[];
     symbolAliases: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').AliasSymbol[]>;
     symbolUses: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').UseSymbol[]>;
-    /**
-      * A global query
-      * Return the named refs visible from a program (refs are not imported via `use`).
-      */
-    visibleSymbols: (program: import('../core/types/symbol').ProgramSymbol, kind: import('../core/types/symbol').SymbolKind) => import('../core/types/symbol').RefSymbol[];
-    /**
-      * A global query
-      * Whether a symbol is visible from a program
-      */
-    isSymbolVisible: (program: import('../core/types/symbol').ProgramSymbol, symbol: import('../core/types/symbol').NodeSymbol) => boolean;
-    /**
-      * A global query
-      * Resolve all candidates that a metadata block can target
-      */
-    metadataTargets: (block: import('../core/types/symbol').MetadataElementMetadata) => import('../core/types/symbol').NodeSymbol[];
     fileDependencies: (filepath: Filepath) => Filepath[];
-    /**
-      * A global query
-      * BFS-traverse imports from an entry filepath and return all reachable files. Related: fileDependencies.
-      */
     reachableFiles: (entry?: Filepath | undefined) => Filepath[];
     usableMembers: (symbolOrFilepath: Filepath | import('../core/types/symbol').SchemaSymbol | import('../core/types/symbol').ProgramSymbol) => import('../core/types/report').default<{
         nonSchemaMembers: import('../core/types/symbol').NodeSymbol[];
@@ -109,7 +90,7 @@ export default class Compiler {
         source: (filepath: Filepath) => string;
         ast: (filepath?: Filepath) => Readonly<import('../core/types/nodes').ProgramNode>;
         errors: (filepath?: Filepath) => readonly Readonly<import('..').CompileError>[];
-        warnings: (filepath?: Filepath) => readonly Readonly<import('../core/types').CompileWarning>[];
+        warnings: (filepath?: Filepath) => readonly Readonly<import('..').CompileWarning>[];
         tokens: (filepath?: Filepath) => readonly Readonly<import('..').SyntaxToken>[];
         rawDb: (filepath?: Filepath) => Readonly<import('..').Database> | undefined;
         publicSymbolTable: (filepath?: Filepath) => readonly Readonly<import('../core/types/symbol').NodeSymbol>[] | undefined;
@@ -130,6 +111,7 @@ export default class Compiler {
     initMonacoServices(options?: {
         autocompletion?: {
             triggerCharacters?: string[];
+            fileListDepth?: number;
         };
     }): {
         definitionProvider: DBMLDefinitionProvider;

package/dist/src/compiler/projectLayout/layout.d.ts

@@ -1,6 +1,12 @@
 import { Filepath } from '../../core/types/filepath';
+export interface FileSpecifierInfo {
+    specifier: string;
+    label?: string;
+    detail?: string;
+}
 export interface DbmlProjectLayout {
     resolveFileSpecifier(currentFilepath: Filepath, specifier: string): Filepath | undefined;
+    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     getSource(filePath: Filepath): string | undefined;
     exists(filePath: Filepath): boolean;
     isFile(filePath: Filepath): boolean;
@@ -12,6 +18,7 @@ export declare class MemoryProjectLayout implements DbmlProjectLayout {
     private readonly files;
     constructor(files?: Map<string, string> | Record<string, string>);
     resolveFileSpecifier(currentFilepath: Filepath, relativePath: string): Filepath | undefined;
+    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     setSource(filePath: Filepath, content: string): void;
     getSource(filePath: Filepath): string | undefined;
     deleteSource(filePath: Filepath): void;

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

@@ -2,13 +2,13 @@ import { default as Compiler } from '../../../compiler';
 import { Filepath } from '../../types';
 import { MetadataElementMetadata } from '../../types/symbol/metadata';
 import { default as Report } from '../../types/report';
-import { MetadataValues } from '../../types/schemaJson';
+import { CustomMetadata } from '../../types/schemaJson';
 export default class MetadataInterpreter {
     private declarationNode;
     private compiler;
     private filepath;
     private values;
     constructor(compiler: Compiler, metadata: MetadataElementMetadata, filepath: Filepath);
-    interpret(): Report<MetadataValues>;
+    interpret(): Report<CustomMetadata>;
     private interpretValues;
 }

package/dist/src/core/global_modules/metadata/registries.d.ts

@@ -0,0 +1,19 @@
+import { SettingName } from '../../types/keywords';
+import { Color, Column, Note, Table, TableGroup } from '../../types/schemaJson';
+import { MetadataTargetKind } from '../../types/symbol';
+import { MetadataFieldRegistry } from './utils';
+export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, {
+    [SettingName.Note]: string;
+    [SettingName.HeaderColor]: Color;
+}>;
+export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, {
+    [SettingName.Note]: string;
+}>;
+export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, {
+    [SettingName.Note]: string;
+    [SettingName.Color]: Color;
+}>;
+export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, {
+    [SettingName.Color]: Color;
+}>;
+export declare const METADATA_FIELDS_BY_KIND: Record<MetadataTargetKind, MetadataFieldRegistry<any, any>>;

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

@@ -1,31 +1,36 @@
 import { default as Compiler } from '../../../compiler/index';
 import { Filepath, SettingName } from '../../types';
-import { Column, CustomMetadataValue, Note, Ref, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
-import { SyntaxNode } from '../../types/nodes';
+import { Column, CustomMetadataValue, CustomMetadataValueType, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
+import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
 import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
-export type MetadataTarget = Table | TableGroup | Note | Column | Ref;
+export type MetadataTarget = Table | TableGroup | Note | Column;
 /**
-  * Specs for builtin metadata (table's note, tablegroup's color, .etc) for different element types. Does 2 things:
-  * - `validate`: Validating if the metadata value is syntactically correct
-  * - `assign`: Write the metadata value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
+  * Spec for one builtin metadata field (table's note, tablegroup's color, .etc) of an element kind.
+  * Used for both the inline settings list and Metadata blocks:
+  * - `parse`: Read the field's own value from a source node, `undefined` means the value is invalid
+  * - `assign`: Write the parsed value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
   */
-interface MetadataField<T extends MetadataTarget> {
-    /** Check if the metadata value is syntactically correct */
-    isValidBuiltinFieldValue(node?: SyntaxNode): boolean;
+type MetadataField<T, V> = {
+    /** Type of the parsed value, reported when the field is read as a metadata entry */
+    type: CustomMetadataValueType;
+    /** Parse the source node into the field's value, `undefined` if the node is not a valid value for this field */
+    parse(node?: SyntaxNode): V | undefined;
     message: string;
-    /** Write the metadata value to the element builtin props (e.g. write to `table.note`) */
-    assignBuiltinField(element: Partial<T>, value: CustomMetadataValue, token: TokenPosition): void;
-}
-export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName> = Record<K, MetadataField<T>>;
-export type NameWithSymbolKind = {
+    /** Write the parsed value to the element builtin props (e.g. write to `table.note`) */
+    assign(element: Partial<T>, value: V, token: TokenPosition): void;
+};
+export type MetadataFieldRegistry<T extends MetadataTarget, R extends {
+    [K in SettingName]?: CustomMetadataValue['value'];
+}> = {
+    [K in keyof R]: MetadataField<T, R[K]>;
+};
+type NameWithSymbolKind = {
     name: string;
     symbolKind: SymbolKind;
 };
 /** @internal Exported for testing only. */
-export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: Exclude<MetadataTargetKind, MetadataTargetKind.Ref>): NameWithSymbolKind[];
-/**
-  * Merge every custom-metadata block applying to the target in the current program (in precedence order) to its `metadata` and other builtin (note/headercolor/...) fields
-  * NOTE: Only run during interpret phase
-  */
+export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: MetadataTargetKind): NameWithSymbolKind[];
+export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): NodeSymbol | undefined;
+/** Merge every custom-metadata block, reachable from the current program, targeting element to it's `metadata` and other builtin (note/headercolor/...) fields */
 export declare function attachCustomMetadata<T extends MetadataTarget>(compiler: Compiler, targetElement: Partial<T>, targetSymbol: NodeSymbol, fieldsRegistry: MetadataFieldRegistry<T, any>, filepath: Filepath): void;
 export {};

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

@@ -1,9 +1,7 @@
 import { Note } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { SettingName, Filepath, NoteSymbol } from '../../types';
+import { Filepath, NoteSymbol } from '../../types';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, SettingName.Color>;
 export declare class StickyNoteInterpreter {
     private declarationNode;
     private symbol;

package/dist/src/core/global_modules/records/utils/data/values.d.ts

@@ -1,9 +1,8 @@
 import { FunctionExpressionNode, SyntaxNode } from '../../../../types/nodes';
-export { extractNumericLiteral } from '../../../../utils/expression';
+export { extractNumericLiteral, extractSignedNumber } from '../../../../utils/expression';
 export declare function isNullish(value: SyntaxNode): boolean;
 export declare function isEmptyStringLiteral(value: SyntaxNode): boolean;
 export declare function isFunctionExpression(value: SyntaxNode): value is FunctionExpressionNode;
-export declare function extractSignedNumber(node: SyntaxNode): number | null;
 export declare function tryExtractNumeric(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
 export declare function tryExtractInteger(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
 export declare const TRUTHY_VALUES: string[];

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

@@ -2,10 +2,6 @@ import { default as Compiler } from '../../../compiler/index';
 import { SyntaxNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
 import { NodeSymbol } from '../../types/symbol';
-import { CompileError } from '../../types';
 import { GlobalModule } from '../types';
-export declare const refUtils: {
-    getDuplicateError(name: string, schemaLabel: string, errorNode: SyntaxNode): CompileError;
-};
 export declare const refModule: GlobalModule;
 export declare function nodeRefereeOfRefEndpoint(compiler: Compiler, globalSymbol: NodeSymbol, node: SyntaxNode): Report<NodeSymbol | undefined>;

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

@@ -1,9 +1,7 @@
 import { Ref } from '../../types/schemaJson';
-import { RefMetadata, SettingName, Filepath } from '../../types';
+import { RefMetadata, Filepath } from '../../types';
 import { default as Compiler } from '../../../compiler';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const REF_METADATA_FIELDS: MetadataFieldRegistry<Ref, SettingName.Color | SettingName.Note>;
 export declare class RefInterpreter {
     private compiler;
     private metadata;

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

@@ -2,10 +2,9 @@ import { default as Compiler } from '../../../compiler';
 import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
-import { Column, Table } from '../../types/schemaJson';
+import { Table } from '../../types/schemaJson';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
-import { MetadataFieldRegistry } from '../metadata/utils';
 export declare class TableInterpreter {
     private declarationNode;
     private compiler;
@@ -33,5 +32,3 @@ export declare class TableInterpreter {
   * TODO: Catch these settings when we support more data types for custom metadata
   */
 export declare const RECOGNIZED_COLUMN_SETTINGS: readonly SettingName[];
-export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, SettingName.Note | SettingName.HeaderColor>;
-export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, SettingName.Note>;

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

@@ -1,9 +1,7 @@
 import { TableGroup } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { SettingName, Filepath, TableGroupSymbol } from '../../types';
+import { Filepath, TableGroupSymbol } from '../../types';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, SettingName.Note | SettingName.Color>;
 export declare class TableGroupInterpreter {
     private compiler;
     private symbol;

package/dist/src/core/local_modules/dep/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
 export default class DepValidator {
     private declarationNode;
     private compiler;
@@ -16,4 +14,3 @@ export default class DepValidator {
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;
 }
-export declare function validateDepSettings(settings: ListExpressionNode): Report<Settings>;

package/dist/src/core/local_modules/note/validate.d.ts

@@ -9,8 +9,6 @@ export default class NoteValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private isStickyNote;
-    private validateSettingList;
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;

package/dist/src/core/local_modules/table/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode, ExpressionNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { ElementDeclarationNode } from '../../types/nodes';
 export default class TableValidator {
     private declarationNode;
     private compiler;
@@ -11,11 +9,7 @@ export default class TableValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private validateSettingList;
     private validateBody;
     private validateFields;
-    private validateFieldSetting;
     private validateSubElements;
 }
-export declare function validateTableSettings(settingList?: ListExpressionNode): Report<Settings>;
-export declare function validateFieldSetting(parts: ExpressionNode[]): Report<Settings>;

package/dist/src/core/local_modules/tableGroup/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
 export default class TableGroupValidator {
     private declarationNode;
     private compiler;
@@ -11,9 +9,7 @@ export default class TableGroupValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private validateSettingList;
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;
 }
-export declare function validateSettingList(settingList?: ListExpressionNode): Report<Settings>;

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

@@ -112,6 +112,10 @@ export declare enum CompileErrorCode {
     DUPLICATE_DIAGRAMVIEW_NAME = 3094,
     INVALID_DIAGRAMVIEW_FIELD = 3095,
     DUPLICATE_DIAGRAMVIEW_FIELD = 3096,
+    DUPLICATE_TABLEGROUP_SETTING = 3097,
+    INVALID_TABLEGROUP_SETTING_VALUE = 3098,
+    DUPLICATE_DEP_SETTING = 3099,
+    INVALID_DEP_SETTING_VALUE = 3100,
     BINDING_ERROR = 4000,
     NONEXISTENT_MODULE = 4001,
     UNSUPPORTED = 5000,

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

@@ -5,10 +5,12 @@ export type FilepathId = string & {
 };
 export declare class Filepath implements Internable<FilepathId> {
     private readonly protocol?;
-    private readonly path;
+    private readonly root;
+    private readonly segments;
     constructor(absolutePath: string, options?: {
         protocol?: string;
     });
+    private get path();
     intern(): FilepathId;
     static from(absolutePath: string): Filepath;
     static resolve(fromDir: string, relativePath: string): Filepath;

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

@@ -2,7 +2,12 @@ import { NONE_COLOR } from '../../../constants';
 import { Filepath } from '../filepath';
 import { Position } from '../position';
 import { RelationshipOp, RelationCardinality } from '../relation';
-export type CustomMetadataValue = string | Color | number | boolean;
+export type CustomMetadataValueType = 'string' | 'number' | 'bool' | 'color';
+export interface CustomMetadataValue {
+    value: string | number | boolean;
+    type: CustomMetadataValueType;
+    token: TokenPosition;
+}
 export type CustomMetadata = Record<string, CustomMetadataValue>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
@@ -165,14 +170,9 @@ export interface Ref {
     name: string | null;
     endpoints: RefEndpointPair;
     color?: Color;
-    note?: {
-        value: string;
-        token: TokenPosition;
-    };
     onDelete?: string;
     onUpdate?: string;
     inactive?: boolean;
-    metadata?: CustomMetadata;
     token: TokenPosition;
 }
 export type RefEndpointPair = [RefEndpoint, RefEndpoint];
@@ -285,10 +285,6 @@ export interface TableRecord {
     example?: boolean;
     token: TokenPosition;
 }
-export type MetadataValues = Record<string, {
-    value: CustomMetadataValue;
-    token: TokenPosition;
-}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -303,4 +299,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;
+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 | CustomMetadata;

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

@@ -16,7 +16,6 @@ export declare enum SymbolKind {
     Enum = "Enum",
     EnumField = "Enum field",
     StickyNote = "Note",
-    Ref = "Ref",
     TablePartial = "TablePartial",
     PartialInjection = "PartialInjection",
     DiagramView = "DiagramView",
@@ -42,8 +41,7 @@ export declare enum MetadataTargetKind {
     Table = "Table",
     Column = "Column",
     TableGroup = "TableGroup",
-    Note = "Note",
-    Ref = "Ref"
+    Note = "Note"
 }
 declare const __nodeSymbolBrand: unique symbol;
 export type NodeSymbolId = number & {
@@ -213,14 +211,6 @@ export declare class NoteSymbol extends NodeSymbol {
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
 }
-export declare class RefSymbol extends NodeSymbol {
-    constructor({ declaration, name, }: {
-        declaration?: SyntaxNode;
-        name?: string;
-    }, id: NodeSymbolId, filepath: Filepath);
-    get canBeImported(): boolean;
-    get originalSymbol(): NodeSymbol;
-}
 export declare class TablePartialSymbol extends NodeSymbol {
     constructor({ declaration, name, }: {
         declaration?: SyntaxNode;

package/dist/src/core/utils/expression.d.ts

@@ -23,6 +23,7 @@ export declare function destructureIndexNode(node?: SyntaxNode): {
 } | undefined;
 export declare function extractQuotedStringToken(value?: SyntaxNode): string | undefined;
 export declare function extractNumericLiteral(node?: SyntaxNode): number | null;
+export declare function extractSignedNumber(node: SyntaxNode): number | null;
 export declare function extractBooleanLiteral(node?: SyntaxNode): boolean | null;
 export declare function destructureCallExpression(node?: SyntaxNode): {
     variables: (PrimaryExpressionNode & {

package/dist/src/core/utils/interpret.d.ts

@@ -4,12 +4,15 @@ import { SyntaxNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { Settings } from './validate';
 import { SettingName } from '../types';
+import { MetadataFieldRegistry, MetadataTarget } from '../global_modules/metadata/utils';
 export declare function getTokenPosition(node: SyntaxNode): TokenPosition;
 export declare function normalizeNote(content: string): string;
 export declare function extractElementName(nameNode: SyntaxNode): {
     schemaName: string[];
     name: string;
 };
+export declare function extractNote(node?: SyntaxNode): string | undefined;
+export declare function extractHexColor(node?: SyntaxNode): Color | undefined;
 export declare function extractColor(node?: SyntaxNode): Color | undefined;
 export declare function processDefaultValue(valueNode?: SyntaxNode): {
     type: 'number' | 'string' | 'boolean' | 'expression';
@@ -17,10 +20,18 @@ export declare function processDefaultValue(valueNode?: SyntaxNode): {
 } | undefined;
 export declare function processColumnType(compiler: Compiler, typeNode: SyntaxNode): Report<ColumnType>;
 /**
-  * Extract inline custom metadata from an aggregated setting list,
-  * excluding keys that are natively attached to the element (headercolor and note in `table`, color in `tablegroup`, .etc).
+  * Extract inline custom metadata from an aggregated setting list, excluding the given recognized settings.
+  * Used for columns, whose recognized settings (pk, ref, note, .etc) are interpreted by the column symbol rather than field specs.
   *
   * NOTE: This is used during interpret phase, so no need to validate values, just extract them
   */
 export declare function extractCustomInlineMetadata(settingMap: Settings, builtinSettings: readonly SettingName[]): CustomMetadata;
-export declare function extractMetadataValue(node?: SyntaxNode): CustomMetadataValue | undefined;
+/**
+  * Interpret an element's aggregated setting list as metadata:
+  * - Builtin fields (headercolor and note in `table`, color in `tablegroup`, .etc) are parsed and assigned onto the element by their field spec
+  * - Every other key becomes free-form custom metadata on `element.metadata`
+  *
+  * Invalid values are skipped (reported at validate phase).
+  */
+export declare function assignInlineMetadata<T extends MetadataTarget>(element: Partial<T>, settingMap: Settings, registry: MetadataFieldRegistry<T, any>): void;
+export declare function extractMetadataValue(node?: SyntaxNode): Omit<CustomMetadataValue, 'token'> | undefined;

package/dist/src/index.d.ts

@@ -8,10 +8,11 @@ export { MetadataKind } from './core/types/symbol/metadata';
 export * from './core/global_modules/records/utils';
 export * from './core/types/nodes';
 export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from './core/types/tokens';
-export { CompileError, CompileErrorCode, } from './core/types/errors';
+export { CompileError, CompileErrorCode, CompileWarning, CompileInfo, } from './core/types/errors';
+export type { Diagnostic, DiagnosticQuickFix } from './services/diagnostics/provider';
 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 CustomMetadataValue, } 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 CustomMetadataValue, type CustomMetadataValueType, } from './core/types/schemaJson';
 export { type RelationCardinality, type RelationshipOp, getRelationshipOp, getMultiplicities, parseCardinality, makeCardinalityRequired, makeCardinalityOptional, makeRelationshipRequired, isEndpointOneSide, isEndpointManySide, isEndpointOptional, isEndpointRequired, CARDINALITY_ONE, CARDINALITY_MAYBE, CARDINALITY_SOME, CARDINALITY_MANY, } from './core/types/relation';
 export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
 export { findDiagramViewBlocks } from './compiler/queries/transform';

package/dist/src/services/definition/provider.d.ts

@@ -4,4 +4,5 @@ export default class DBMLDefinitionProvider implements DefinitionProvider {
     private compiler;
     constructor(compiler: Compiler);
     provideDefinition(model: TextModel, position: Position): Definition;
+    private resolveImportPath;
 }

package/dist/src/services/suggestions/provider.d.ts

@@ -20,11 +20,13 @@ export declare const TABLE_BODY_SUGGESTION_LABELS: ("indexes" | "checks" | "Note
 export declare const PROJECT_FIELD_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref" | "Dep")[];
 export interface DBMLCompletionItemProviderOptions {
     triggerCharacters?: string[];
+    fileListDepth?: number;
 }
 export default class DBMLCompletionItemProvider implements CompletionItemProvider {
     private compiler;
     triggerCharacters: string[];
+    fileListDepth: number;
     constructor(compiler: Compiler, options?: DBMLCompletionItemProviderOptions);
     provideCompletionItems(model: TextModel, position: Position): CompletionList;
 }
-export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "Ref" | "DiagramView" | "Metadata" | "Dep" | "Project" | "Records")[];
+export declare const TOP_LEVEL_SUGGESTION_LABELS: ("Table" | "Enum" | "TableGroup" | "TablePartial" | "Note" | "DiagramView" | "Metadata" | "Ref" | "Dep" | "Project" | "Records")[];

package/dist/src/services/suggestions/use.d.ts

@@ -2,4 +2,7 @@ import { default as Compiler } from '../../compiler';
 import { Filepath } from '../../core/types/filepath';
 import { SyntaxToken } from '../../core/types/tokens';
 import { CompletionList, TextModel } from '../types';
-export declare function suggestUseCompletion(compiler: Compiler, filepath: Filepath, offset: number, bOcToken: SyntaxToken | undefined, model: TextModel): CompletionList | null;
+export interface SuggestUseCompletionOptions {
+    fileListDepth?: number;
+}
+export declare function suggestUseCompletion(compiler: Compiler, filepath: Filepath, offset: number, bOcToken: SyntaxToken | undefined, model: TextModel, options?: SuggestUseCompletionOptions): CompletionList | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/parse",
-  "version": "10.4.0-metadata-ref-type.0",
+  "version": "10.4.0-metadata-type.0",
   "description": "DBML parser v2",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -25,7 +25,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf ./dist && tsc --noEmit && vite build",
+    "build": "rimraf ./dist && tsc --noEmit && vite build",
     "dev": "vite build --watch",
     "test": "vitest run",
     "test:watch": "vitest watch",
@@ -51,5 +51,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "f2806cfb089ae685523e444dd409fd1e4514962b"
+  "gitHead": "0346035c1c3c2bb1f8b1e524e43a43ad4cc9bb8e"
 }

package/dist/src/compiler/queries/metadata/isSymbolVisible.d.ts

@@ -1,10 +0,0 @@
-import { NodeSymbol, ProgramSymbol } from '../../../core/types/symbol';
-import { default as Compiler } from '../../index';
-/**
-  * Whether `symbol` is visible from `program`.
-  * - Column: visible when its table is (a column is not a direct schema member)
-  * - Ref: refs are not imported via `use`, a ref is visible when it shows up in the program's output,
-  *   i.e. the program reaches the ref's file and sees both endpoint tables (RefMetadata.owners)
-  * - otherwise: the symbol sits in the program's schemas, directly or through `use`
-  */
-export declare function isSymbolVisible(this: Compiler, program: ProgramSymbol, symbol: NodeSymbol): boolean;

package/dist/src/compiler/queries/metadata/metadataTargets.d.ts

@@ -1,7 +0,0 @@
-import { NodeSymbol } from '../../../core/types/symbol';
-import { MetadataElementMetadata } from '../../../core/types/symbol/metadata';
-import { default as Compiler } from '../../index';
-/**
-  * Resolve the candidates a Metadata block targets, from its `<target-kind> <name>` header.
-  */
-export declare function metadataTargets(this: Compiler, block: MetadataElementMetadata): NodeSymbol[];

package/dist/src/compiler/queries/symbol/visibleSymbols.d.ts

@@ -1,7 +0,0 @@
-import { ProgramSymbol, RefSymbol, SymbolKind } from '../../../core/types/symbol';
-import { default as Compiler } from '../../index';
-/**
-  * Named refs usable from `program`: refs are not imported via `use`, a named ref is visible
-  * wherever it shows up in the output (see isSymbolVisible).
-  */
-export declare function visibleSymbols(this: Compiler, program: ProgramSymbol, kind: SymbolKind): RefSymbol[];