@dbml/parse 11.0.0-alpha.6 → 11.0.1-alpha.0

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

@@ -1,39 +1,20 @@
-import { GlobalModule } from '../core/global_modules/types';
-import { ParserOptions } from '../core/parser/parser';
-import { LexerOptions } from '../core/lexer/lexer';
-import { SyntaxToken } from '../core/types/tokens';
-import { FileKind, FileScan } from './queries/files/fileKind';
 import { Filepath } from '../core/types/filepath';
 import { SyntaxNode, SyntaxNodeIdGenerator } from '../core/types/nodes';
 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';
-export interface DialectOptions {
-    lexer?: LexerOptions;
-    parser?: ParserOptions;
-}
+import { addDoubleQuoteIfNeeded, escapeString, formatTypedValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, TypedValue } from './queries/utils';
 export { ScopeKind } from './types';
 export type { TextEdit } from './queries/transform';
-export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
+export { addDoubleQuoteIfNeeded, escapeString, formatTypedValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
+export type { TypedValue };
 export default class Compiler {
     layout: DbmlProjectLayout;
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
     readonly symbolIdGenerator: NodeSymbolIdGenerator;
     readonly symbolFactory: SymbolFactory;
-    readonly explicitModules: GlobalModule[] | undefined;
-    private readonly explicitDialect;
-    readonly dialect: DialectOptions;
-    constructor(layout: DbmlProjectLayout, modules?: GlobalModule[], dialect?: DialectOptions);
+    constructor(layout: DbmlProjectLayout);
     getSource(filepath: Filepath): string | undefined;
-    lexerOptions(): LexerOptions;
-    parserOptions(kind: FileKind): ParserOptions;
-    private fileScans;
-    private fileKinds;
-    scanFile(filepath: Filepath, tokens?: readonly SyntaxToken[]): FileScan;
-    fileKind(filepath: Filepath): FileKind;
-    fileKindForParse(filepath: Filepath, tokens?: readonly SyntaxToken[]): FileKind;
-    parsedFileKind(filepath: Filepath): FileKind;
     private sourceSnapshot;
     private cleanStaleLocalCache;
     private entrypointsSnapshot;
@@ -90,11 +71,13 @@ export default class Compiler {
             }[];
         };
     }>;
-    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | SyntaxToken | undefined;
+    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | import('..').SyntaxToken | undefined;
     renameTable: (filepath: Filepath, oldName: string | import('..').TableIdentifier, newName: string | import('..').TableIdentifier) => Map<string, string>;
-    renameElement: (filepath: Filepath, oldHandle: string, newName: string) => Map<string, string>;
     updateElementSetting: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => string;
     updateElementSettingEdit: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => import('.').TextEdit[];
+    findMetadataBlock: (filepath: Filepath, target: import('..').ElementIdentifier) => import('../core/types/nodes').ElementDeclarationNode | undefined;
+    updateElementMetadata: (filepath: Filepath, target: import('..').ElementIdentifier, key: string, value: TypedValue) => string;
+    updateElementMetadataEdit: (filepath: Filepath, target: import('..').ElementIdentifier, key: string, value: TypedValue) => import('.').TextEdit[];
     syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: import('..').DiagramViewBlock[] | undefined) => {
         newDbml: string;
         edits: import('.').TextEdit[];
@@ -104,22 +87,22 @@ export default class Compiler {
         edits: import('.').TextEdit[];
     };
     readonly token: {
-        invalidStream: (filepath: Filepath) => readonly SyntaxToken[];
-        flatStream: (filepath: Filepath) => readonly SyntaxToken[];
+        invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
+        flatStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
     };
     readonly parse: {
         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>[];
-        tokens: (filepath?: Filepath) => readonly Readonly<SyntaxToken>[];
+        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;
     };
     readonly container: {
         stack: (filepath: Filepath, offset: number) => readonly Readonly<SyntaxNode>[];
         token: (filepath: Filepath, offset: number) => {
-            token: SyntaxToken;
+            token: import('..').SyntaxToken;
             index: number;
         } | {
             token: undefined;
@@ -132,6 +115,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/compiler/queries/transform/index.d.ts

@@ -1,7 +1,7 @@
 export { renameTable } from './renameTable';
-export { renameElement } from './renameElement';
 export { updateElementSetting, updateElementSettingEdit } from './updateElementSetting';
+export { findMetadataBlock, updateElementMetadata, updateElementMetadataEdit, syncElementMetadata, } from './updateElementMetadata';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
 export { syncDep, generateDepBlock, type DepSyncOperation, type DepSyncEdge, type DepEndpointRef, } from './syncDep';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
-export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, ArchElementIdentifier, ArchLinkIdentifier, } from './types';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './types';

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

@@ -1,6 +1,6 @@
 import { SymbolKind } from '../../../core/types/symbol';
 import { MetadataKind } from '../../../core/types/symbol/metadata';
-export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier | ArchElementIdentifier | ArchLinkIdentifier) & {
+export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier) & {
     kind: string;
 };
 export interface SchemaIdentifier {
@@ -46,12 +46,3 @@ export interface TableGroupIdentifier {
     schema?: string;
     name: string;
 }
-export interface ArchElementIdentifier {
-    kind?: typeof SymbolKind.Element;
-    name: string;
-}
-export interface ArchLinkIdentifier {
-    kind?: 'Link';
-    from: string;
-    to: string;
-}

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

@@ -0,0 +1,13 @@
+import { Filepath } from '../../../core/types/filepath';
+import { ElementDeclarationNode } from '../../../core/types/nodes';
+import { default as Compiler } from '../../index';
+import { TextEdit } from './applyTextEdits';
+import { ElementIdentifier } from './types';
+import { TypedValue } from '../utils';
+export declare function findMetadataBlock(this: Compiler, filepath: Filepath, target: ElementIdentifier): ElementDeclarationNode | undefined;
+export declare function updateElementMetadataEdit(this: Compiler, filepath: Filepath, target: ElementIdentifier, key: string, value: TypedValue | null): TextEdit[];
+export declare function updateElementMetadata(this: Compiler, filepath: Filepath, target: ElementIdentifier, key: string, value: TypedValue | null): string;
+export declare function syncElementMetadata(source: string, compiler: Compiler, filepath: Filepath, target: ElementIdentifier, key: string, value: TypedValue | null): {
+    newDbml: string;
+    edits: TextEdit[];
+};

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

@@ -70,20 +70,22 @@ export declare function escapeString(str: string): string;
  * @returns The formatted string representation for DBML
  *
  * @example
- * formatRecordValue({ value: 1, type: 'integer' }) => '1'
- * formatRecordValue({ value: 'Alice', type: 'string' }) => "'Alice'"
- * formatRecordValue({ value: true, type: 'bool' }) => 'true'
- * formatRecordValue({ value: null, type: 'string' }) => 'null'
- * formatRecordValue(undefined) => 'null'
- * formatRecordValue(null) => 'null'
- * formatRecordValue('Alice') => "'Alice'"
- * formatRecordValue(42) => '42'
- * formatRecordValue(true) => 'true'
+ * formatTypedValue({ value: 1, type: 'integer' }) => '1'
+ * formatTypedValue({ value: 'Alice', type: 'string' }) => "'Alice'"
+ * formatTypedValue({ value: true, type: 'bool' }) => 'true'
+ * formatTypedValue({ value: null, type: 'string' }) => 'null'
+ * formatTypedValue({ value: '#ff0000', type: 'color' }) => '#ff0000'
+ * formatTypedValue(undefined) => 'null'
+ * formatTypedValue(null) => 'null'
+ * formatTypedValue('Alice') => "'Alice'"
+ * formatTypedValue(42) => '42'
+ * formatTypedValue(true) => 'true'
  */
-export declare function formatRecordValue(recordValue: {
+export type TypedValue = {
     value: any;
     type: string;
-} | string | number | boolean | null | undefined): string;
+} | string | number | boolean | null | undefined;
+export declare function formatTypedValue(recordValue: TypedValue): string;
 /**
  * Splits a qualified identifier string into its components, handling quoted segments.
  *

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

@@ -7,8 +7,7 @@ import { NodeMetadata } from '../types/symbol/metadata';
 import { SchemaElement } from '../types/schemaJson';
 import { NodeSymbol } from '../types/symbol';
 import { GlobalModule } from './types';
-export declare const dbmlModules: GlobalModule[];
-export declare const archModules: GlobalModule[];
+export declare const modules: GlobalModule[];
 export declare function nodeSymbol(this: Compiler, node: SyntaxNode): Report<NodeSymbol> | Report<Unhandled>;
 export declare function symbolMembers(this: Compiler, symbol: NodeSymbol): Report<NodeSymbol[]> | Report<Unhandled>;
 export declare function nodeReferee(this: Compiler, node: SyntaxNode): Report<NodeSymbol | undefined> | Report<Unhandled>;

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,22 +1,29 @@
 import { default as Compiler } from '../../../compiler/index';
-import { Filepath, FilepathId, SettingName } from '../../types';
-import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
+import { Filepath, SettingName } from '../../types';
+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;
 /**
-  * 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: string, token: TokenPosition): void;
-}
-export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName = SettingName> = Record<K, MetadataField<T>>;
+    /** 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;
@@ -24,8 +31,6 @@ type NameWithSymbolKind = {
 /** @internal Exported for testing only. */
 export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: MetadataTargetKind): NameWithSymbolKind[];
 export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): NodeSymbol | undefined;
-/** Get precedence score of files in import tree, lower score means lower precedence */
-export declare function metadataFilePrecedence(compiler: Compiler, root: Filepath): Map<FilepathId, number>;
 /** 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/program/bind.d.ts

@@ -6,7 +6,6 @@ export default class Binder {
     private compiler;
     constructor(ast: ProgramNode, compiler: Compiler);
     resolve(): Report<void>;
-    private isArchFile;
     private checkDuplicateRefs;
     private checkStandaloneRefs;
     private checkInlineRefs;

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

@@ -14,8 +14,6 @@ export default class ProgramInterpreter {
     private db;
     constructor(compiler: Compiler, symbol: ProgramSymbol, filepath: Filepath);
     interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
-    private arch;
-    private finishArch;
     private interpretAllSymbols;
     private interpretUseSymbol;
     private interpretAllMetadata;

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/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/lexer/lexer.d.ts

@@ -1,9 +1,6 @@
 import { Filepath } from '../types/filepath';
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
-export interface LexerOptions {
-    allowFrontMatter?: boolean;
-}
 export default class Lexer {
     private start;
     private current;
@@ -11,9 +8,7 @@ export default class Lexer {
     private filepath;
     private tokens;
     private errors;
-    private readonly options;
-    constructor(text: string, filepath: Filepath, options?: LexerOptions);
-    private scanFrontMatter;
+    constructor(text: string, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;

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/index.d.ts

@@ -4,7 +4,6 @@ import { SyntaxNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { LocalModule, Settings } from './types';
 export declare const modules: LocalModule[];
-export declare const archModules: LocalModule[];
 export declare function validateNode(this: Compiler, node: SyntaxNode): Report<void> | Report<Unhandled>;
 export declare function nodeSettings(this: Compiler, node: SyntaxNode): Report<Settings> | Report<Unhandled>;
 export declare function nodeFullname(this: Compiler, node: SyntaxNode): Report<string[] | undefined> | Report<Unhandled>;

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/parser/parser.d.ts

@@ -2,9 +2,6 @@ import { Filepath } from '../types/filepath';
 import { ProgramNode, SyntaxNodeIdGenerator } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { SyntaxToken } from '../types/tokens';
-export interface ParserOptions {
-    allowBodylessElement?: boolean;
-}
 export default class Parser {
     private tokens;
     private current;
@@ -13,8 +10,7 @@ export default class Parser {
     private nodeFactory;
     private source;
     private filepath;
-    private readonly options;
-    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath, options?: ParserOptions);
+    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;

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,
@@ -127,22 +131,7 @@ export declare enum CompileErrorCode {
     INVALID_METADATA_TARGET_KIND = 5010,
     INVALID_METADATA_FIELD = 5011,
     DUPLICATE_METADATA_FIELD = 5012,
-    UNKNOWN_ROLE = 6000,
-    MISSING_NAME = 6001,
-    NO_CUSTOM_ROLE = 6002,
-    UNKNOWN_ENDPOINT = 6003,
-    EMPTY_LINK = 6004,
-    BAD_LINK = 6005,
-    UNKNOWN_METADATA_TARGET = 6006,
-    BAD_PROPERTY = 6007,
-    DUPLICATE_PROPERTY = 6008,
-    DIAGRAM_TYPE_NOT_HERE = 6009,
-    METADATA_ROLE_MISMATCH = 6010,
-    UNKNOWN_TYPE = 6011,
-    UNKNOWN_ICON = 6012,
-    BAD_IMAGE = 6013,
-    DUPLICATE_LINK = 6014,
-    NESTED_ENDPOINTS = 6015
+    IMPORTED_FILE_HAS_ERRORS = 5013
 }
 export interface RelatedLocation {
     nodeOrToken: SyntaxNode | SyntaxToken;

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/nodes.d.ts

@@ -95,7 +95,6 @@ export declare class UseSpecifierNode extends SyntaxNode {
         asKeyword?: SyntaxToken;
         alias?: NormalExpressionNode;
     }, id: SyntaxNodeId, filepath: Filepath);
-    archImport?: boolean;
     isKind(...importKinds: ImportKind[]): boolean;
     getSymbolKind(): SymbolKind | undefined;
 }