@dbml/parse 7.0.0 → 7.1.0-alpha.0

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

@@ -1,8 +1,7 @@
-import { SyntaxToken, SyntaxTokenKind } from '../lexer/tokens';
-import { Option } from '../option';
 import { default as NodeFactory } from './factory';
-import { CommaExpressionNode, ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from './nodes';
-export declare function convertFuncAppToElem(_callee: ExpressionNode | CommaExpressionNode | undefined, _args: (NormalExpressionNode | CommaExpressionNode)[], factory: NodeFactory): Option<ElementDeclarationNode>;
+import { CommaExpressionNode, ElementDeclarationNode, ExpressionNode, IdentiferStreamNode, InfixExpressionNode, LiteralNode, NormalExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
+import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
+export declare function convertFuncAppToElem(_callee: ExpressionNode | CommaExpressionNode | undefined, _args: (NormalExpressionNode | CommaExpressionNode)[], factory: NodeFactory): ElementDeclarationNode | undefined;
 export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken & {
     kind: SyntaxTokenKind.IDENTIFIER;
     value: 'as';
@@ -10,7 +9,7 @@ export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken &
 export declare function markInvalid(nodeOrToken?: SyntaxNode | SyntaxToken): void;
 export declare function isInvalidToken(token?: SyntaxToken): boolean;
 export declare function getMemberChain(node: SyntaxNode): Readonly<(SyntaxNode | SyntaxToken)[]>;
-export declare function extractVariableNode(value?: unknown): Option<SyntaxToken>;
+export declare function extractVariableNode(value?: unknown): SyntaxToken | undefined;
 export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
     expression: VariableNode & {
         variable: SyntaxToken & {
@@ -49,6 +48,6 @@ type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
 });
 export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
 export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
-export declare function extractStringFromIdentifierStream(stream?: IdentiferStreamNode): Option<string>;
-export declare function getElementNameString(element?: ElementDeclarationNode): Option<string>;
+export declare function extractStringFromIdentifierStream(stream?: IdentiferStreamNode): string | undefined;
+export declare function getElementNameString(element?: ElementDeclarationNode): string | undefined;
 export {};

package/dist/src/core/{errors.d.ts → types/errors.d.ts}

@@ -1,5 +1,6 @@
-import { SyntaxToken } from './lexer/tokens';
-import { SyntaxNode } from './parser/nodes';
+import { SyntaxNode } from './nodes';
+import { SyntaxToken } from './tokens';
+import { Filepath } from './filepath';
 export declare enum CompileErrorCode {
     UNKNOWN_SYMBOL = 1000,
     UNEXPECTED_SYMBOL = 1001,
@@ -115,6 +116,7 @@ export declare class CompileError extends Error {
     end: Readonly<number>;
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
     toWarning(): CompileWarning;
+    get filepath(): Filepath;
 }
 export declare class CompileWarning extends Error {
     code: Readonly<CompileErrorCode>;
@@ -123,4 +125,5 @@ export declare class CompileWarning extends Error {
     start: Readonly<number>;
     end: Readonly<number>;
     constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
+    get filepath(): Filepath;
 }

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

@@ -0,0 +1,26 @@
+import { Internable } from './internable';
+declare const __filepathIdBrand: unique symbol;
+export type FilepathId = string & {
+    [__filepathIdBrand]: true;
+};
+export declare class Filepath implements Internable<FilepathId> {
+    private readonly path;
+    constructor(absolutePath: string);
+    intern(): FilepathId;
+    static from(absolutePath: string): Filepath;
+    static resolve(fromDir: string, relativePath: string): Filepath;
+    static fromUri(uri: string): Filepath;
+    get absolute(): string;
+    get dirname(): string;
+    get basename(): string;
+    get extname(): string;
+    resolve(relativePath: string): Filepath;
+    join(...segments: string[]): Filepath;
+    relativeTo(baseDir: string): string;
+    toString(): string;
+    equals(other: Filepath): boolean;
+    toUri(): string;
+    static isRelative(p: string): boolean;
+}
+export declare function resolveImportFilepath(currentFilepath: Filepath, relativePath: string): Filepath | undefined;
+export {};

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

@@ -0,0 +1,7 @@
+export * from './errors';
+export * from './report';
+export * from './position';
+export * from './filepath';
+export * from './internable';
+export * from './symbol';
+export * from './schemaJson';

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

@@ -0,0 +1,20 @@
+export interface Internable<Id extends Primitive> {
+    intern(): Id;
+}
+export type Primitive = string | number | boolean | symbol | bigint | null | undefined;
+export declare function intern<T extends Primitive, Id extends Primitive>(value: Internable<Id> | T | T[]): Id | T | string;
+export declare function intern<Id extends Primitive>(value: Internable<Id>): Id;
+export declare function intern<T extends Primitive>(value: T): T;
+export declare function intern<T extends Primitive>(value: T[]): string;
+export declare class InternedMap<K extends Internable<P>, V, P extends Primitive = ReturnType<K['intern']>> {
+    private readonly map;
+    constructor();
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    get size(): number;
+    entries(): IterableIterator<[P, V]>;
+    [Symbol.iterator](): IterableIterator<[P, V]>;
+    merge(other: InternedMap<K, V, P>): this;
+}

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

@@ -0,0 +1,9 @@
+import { default as Compiler } from '../../compiler';
+import { default as Report } from './report';
+export declare const PASS_THROUGH: unique symbol;
+export type PassThrough = typeof PASS_THROUGH;
+export declare const UNHANDLED: unique symbol;
+export type Unhandled = typeof UNHANDLED;
+export interface Module {
+    [index: string]: undefined | ((compiler: Compiler, ...args: any[]) => Report<unknown> | Report<PassThrough>);
+}

package/dist/src/core/{parser → types}/nodes.d.ts

@@ -1,24 +1,34 @@
-import { SyntaxToken } from '../lexer/tokens';
-import { NodeSymbol } from '../analyzer/symbol/symbols';
-import { Position } from '../types';
+import { ElementKind } from '../analyzer/types';
+import { Position } from '.';
+import { Filepath } from './filepath';
+import { Internable } from './internable';
+import { NodeSymbol } from './symbol/symbols';
+import { SyntaxToken } from './tokens';
 export type SyntaxNodeId = number;
+export type InternedSyntaxNode = string;
 export declare class SyntaxNodeIdGenerator {
     private id;
     reset(): void;
     nextId(): SyntaxNodeId;
 }
-export declare class SyntaxNode {
+export declare class SyntaxNode implements Internable<InternedSyntaxNode> {
     id: Readonly<SyntaxNodeId>;
     kind: SyntaxNodeKind;
+    readonly filepath: Filepath;
     startPos: Readonly<Position>;
     start: Readonly<number>;
     fullStart: Readonly<number>;
     endPos: Readonly<Position>;
     end: Readonly<number>;
     fullEnd: Readonly<number>;
+    parentNode?: SyntaxNode;
     symbol?: NodeSymbol;
     referee?: NodeSymbol;
-    constructor(id: SyntaxNodeId, kind: SyntaxNodeKind, args: Readonly<SyntaxToken | SyntaxNode | undefined>[]);
+    constructor(id: SyntaxNodeId, kind: SyntaxNodeKind, filepath: Filepath, args: Readonly<SyntaxToken | SyntaxNode | undefined>[]);
+    intern(): InternedSyntaxNode;
+    parentOfKind<T extends SyntaxNode>(cls: (new (...args: any[]) => T)): T | undefined;
+    strictlyContains(otherNode: SyntaxNode): boolean;
+    containsEq(otherNode: SyntaxNode): boolean;
 }
 export declare enum SyntaxNodeKind {
     PROGRAM = "<program>",
@@ -47,11 +57,11 @@ export declare class ProgramNode extends SyntaxNode {
     body: ElementDeclarationNode[];
     eof?: SyntaxToken;
     source: string;
-    constructor({ body, eof, source }: {
+    constructor({ body, eof, source, }: {
         body?: ElementDeclarationNode[];
         eof?: SyntaxToken;
         source: string;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class ElementDeclarationNode extends SyntaxNode {
     type?: SyntaxToken;
@@ -70,13 +80,14 @@ export declare class ElementDeclarationNode extends SyntaxNode {
         attributeList?: ListExpressionNode;
         bodyColon?: SyntaxToken;
         body?: BlockExpressionNode | FunctionApplicationNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
+    isKind(...kinds: ElementKind[]): boolean;
 }
 export declare class IdentiferStreamNode extends SyntaxNode {
     identifiers: SyntaxToken[];
-    constructor({ identifiers }: {
+    constructor({ identifiers, }: {
         identifiers?: SyntaxToken[];
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class AttributeNode extends SyntaxNode {
     name?: IdentiferStreamNode | PrimaryExpressionNode;
@@ -86,17 +97,17 @@ export declare class AttributeNode extends SyntaxNode {
         name?: IdentiferStreamNode | PrimaryExpressionNode;
         colon?: SyntaxToken;
         value?: NormalExpressionNode | IdentiferStreamNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export type NormalExpressionNode = PrefixExpressionNode | InfixExpressionNode | PostfixExpressionNode | BlockExpressionNode | ListExpressionNode | TupleExpressionNode | CommaExpressionNode | CallExpressionNode | PrimaryExpressionNode | FunctionExpressionNode | EmptyNode | ArrayNode;
 export type ExpressionNode = ElementDeclarationNode | NormalExpressionNode | FunctionApplicationNode;
 export declare class PrefixExpressionNode extends SyntaxNode {
     op?: SyntaxToken;
     expression?: NormalExpressionNode;
-    constructor({ op, expression }: {
+    constructor({ op, expression, }: {
         op?: SyntaxToken;
         expression?: NormalExpressionNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class InfixExpressionNode extends SyntaxNode {
     op?: SyntaxToken;
@@ -106,29 +117,29 @@ export declare class InfixExpressionNode extends SyntaxNode {
         op?: SyntaxToken;
         leftExpression?: NormalExpressionNode;
         rightExpression?: NormalExpressionNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class PostfixExpressionNode extends SyntaxNode {
     op?: SyntaxToken;
     expression?: NormalExpressionNode;
-    constructor({ op, expression }: {
+    constructor({ op, expression, }: {
         op?: SyntaxToken;
         expression?: NormalExpressionNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class FunctionExpressionNode extends SyntaxNode {
     value?: SyntaxToken;
-    constructor({ value }: {
+    constructor({ value, }: {
         value?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class FunctionApplicationNode extends SyntaxNode {
     callee?: ExpressionNode;
     args: ExpressionNode[];
-    constructor({ callee, args }: {
+    constructor({ callee, args, }: {
         callee?: ExpressionNode;
         args?: ExpressionNode[];
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class BlockExpressionNode extends SyntaxNode {
     blockOpenBrace?: SyntaxToken;
@@ -138,7 +149,7 @@ export declare class BlockExpressionNode extends SyntaxNode {
         blockOpenBrace?: SyntaxToken;
         body?: (ElementDeclarationNode | FunctionApplicationNode)[];
         blockCloseBrace?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class ListExpressionNode extends SyntaxNode {
     listOpenBracket?: SyntaxToken;
@@ -150,7 +161,7 @@ export declare class ListExpressionNode extends SyntaxNode {
         elementList?: AttributeNode[];
         commaList?: SyntaxToken[];
         listCloseBracket?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class TupleExpressionNode extends SyntaxNode {
     tupleOpenParen?: SyntaxToken;
@@ -162,7 +173,7 @@ export declare class TupleExpressionNode extends SyntaxNode {
         elementList?: NormalExpressionNode[];
         commaList?: SyntaxToken[];
         tupleCloseParen?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class CommaExpressionNode extends SyntaxNode {
     elementList: NormalExpressionNode[];
@@ -170,14 +181,14 @@ export declare class CommaExpressionNode extends SyntaxNode {
     constructor({ elementList, commaList, }: {
         elementList?: NormalExpressionNode[];
         commaList?: SyntaxToken[];
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class GroupExpressionNode extends TupleExpressionNode {
     constructor({ groupOpenParen, expression, groupCloseParen, }: {
         groupOpenParen?: SyntaxToken;
         expression?: NormalExpressionNode;
         groupCloseParen?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class CallExpressionNode extends SyntaxNode {
     callee?: NormalExpressionNode;
@@ -185,42 +196,42 @@ export declare class CallExpressionNode extends SyntaxNode {
     constructor({ callee, argumentList, }: {
         callee?: NormalExpressionNode;
         argumentList?: TupleExpressionNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class LiteralNode extends SyntaxNode {
     literal?: SyntaxToken;
-    constructor({ literal }: {
+    constructor({ literal, }: {
         literal?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class WildcardNode extends SyntaxNode {
     token?: SyntaxToken;
-    constructor({ token }: {
+    constructor({ token, }: {
         token?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class VariableNode extends SyntaxNode {
     variable?: SyntaxToken;
-    constructor({ variable }: {
+    constructor({ variable, }: {
         variable?: SyntaxToken;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class PrimaryExpressionNode extends SyntaxNode {
     expression?: LiteralNode | VariableNode;
-    constructor({ expression }: {
+    constructor({ expression, }: {
         expression?: LiteralNode | VariableNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class EmptyNode extends SyntaxNode {
-    constructor({ prevToken }: {
+    constructor({ prevToken, }: {
         prevToken: Readonly<SyntaxNode> | Readonly<SyntaxToken>;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }
 export declare class ArrayNode extends SyntaxNode {
     array?: NormalExpressionNode;
     indexer?: ListExpressionNode;
-    constructor({ expression, indexer }: {
+    constructor({ expression, indexer, }: {
         expression?: NormalExpressionNode;
         indexer: ListExpressionNode;
-    }, id: SyntaxNodeId);
+    }, id: SyntaxNodeId, filepath: Filepath);
 }

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

@@ -0,0 +1,18 @@
+import { CompileError, CompileWarning } from './errors';
+export default class Report<T> {
+    private value;
+    private errors;
+    private warnings?;
+    static create<T>(value: T, errors?: CompileError[], warnings?: CompileWarning[]): Report<T>;
+    constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[]);
+    filter<S extends symbol>(filteredValue: S): Report<undefined | Exclude<T, S>>;
+    hasValue<S>(value: S): this is Report<S>;
+    getFiltered<S extends symbol>(filteredValue: S): Exclude<T, typeof filteredValue> | undefined;
+    getValue(): T;
+    getErrors(): CompileError[];
+    getWarnings(): CompileWarning[];
+    chainFiltered<S extends symbol, U>(filteredValue: S, fn: (_: Exclude<T, S>) => Report<U>): Report<U | undefined>;
+    chain<U>(fn: (_: T) => Report<U>): Report<U>;
+    mapFiltered<S extends symbol, U>(filteredValue: S, fn: (_: T) => U): Report<U | undefined>;
+    map<U>(fn: (_: T) => U): Report<U>;
+}

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

@@ -0,0 +1,243 @@
+import { Filepath } from './filepath';
+import { Position } from './position';
+export interface TokenPosition {
+    start: Position;
+    end: Position;
+    filepath: Filepath;
+}
+export interface ElementRef {
+    name: string;
+    schemaName: string | null;
+    visibleNames: {
+        schemaName: string | null;
+        name: string;
+    }[];
+}
+/**
+ * FilterConfig is a tri-state filter:
+ * - [] (empty array) = show all
+ * - [...] (array with items) = show only these specific items
+ * - null = hide all
+ */
+export interface FilterConfig {
+    tables: Array<{
+        name: string;
+        schemaName: string;
+    }> | null;
+    stickyNotes: Array<{
+        name: string;
+    }> | null;
+    tableGroups: Array<{
+        name: string;
+    }> | null;
+    schemas: Array<{
+        name: string;
+    }> | null;
+}
+export interface DiagramView {
+    name: string;
+    schemaName: string | null;
+    visibleEntities: FilterConfig;
+    token: TokenPosition;
+}
+export interface Database {
+    schemas: [];
+    tables: Table[];
+    notes: Note[];
+    refs: Ref[];
+    enums: Enum[];
+    tableGroups: TableGroup[];
+    aliases: Alias[];
+    project?: Project;
+    tablePartials: TablePartial[];
+    records: TableRecord[];
+    diagramViews: DiagramView[];
+    token?: TokenPosition;
+}
+export interface MasterDatabase {
+    files: Record<string, Database>;
+    items: Database;
+}
+export interface Table {
+    name: string;
+    schemaName: string | null;
+    alias: string | null;
+    fields: Column[];
+    checks: Check[];
+    partials: TablePartialInjection[];
+    token: TokenPosition;
+    indexes: Index[];
+    headerColor?: string;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface Note {
+    name: string;
+    content: string;
+    token: TokenPosition;
+    headerColor?: string;
+}
+export interface ColumnType {
+    schemaName: string | null;
+    type_name: string;
+    args: string | null;
+    numericParams?: {
+        precision: number;
+        scale: number;
+    };
+    lengthParam?: {
+        length: number;
+    };
+    isEnum?: boolean;
+}
+export interface Column {
+    name: string;
+    type: ColumnType;
+    token: TokenPosition;
+    inline_refs: InlineRef[];
+    checks: Check[];
+    pk?: boolean;
+    dbdefault?: {
+        type: 'number' | 'string' | 'boolean' | 'expression';
+        value: number | string;
+    };
+    increment?: boolean;
+    unique?: boolean;
+    not_null?: boolean;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface Index {
+    columns: {
+        value: string;
+        type: string;
+        token: TokenPosition;
+    }[];
+    token: TokenPosition;
+    unique?: boolean;
+    pk?: boolean;
+    name?: string;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+    type?: string;
+}
+export interface Check {
+    token: TokenPosition;
+    expression: string;
+    name?: string;
+}
+export interface InlineRef {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    relation: '>' | '<' | '-' | '<>';
+    token: TokenPosition;
+}
+export interface Ref {
+    schemaName: string | null;
+    name: string | null;
+    endpoints: RefEndpointPair;
+    color?: string;
+    onDelete?: string;
+    onUpdate?: string;
+    token: TokenPosition;
+}
+export type RefEndpointPair = [RefEndpoint, RefEndpoint];
+export interface RefEndpoint {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    relation: RelationCardinality;
+    token: TokenPosition;
+}
+export type RelationCardinality = '1' | '*';
+export interface Enum {
+    name: string;
+    schemaName: string | null;
+    token: TokenPosition;
+    values: EnumField[];
+}
+export interface EnumField {
+    name: string;
+    token: TokenPosition;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface TableGroup {
+    name: string | null;
+    schemaName: string | null;
+    tables: TableGroupField[];
+    token: TokenPosition;
+    color?: string;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface TableGroupField {
+    name: string;
+    schemaName: string | null;
+}
+export type AliasKind = 'table' | 'enum' | 'tablegroup' | 'tablepartial' | 'note';
+export interface Alias {
+    name: string;
+    kind: AliasKind;
+    value: {
+        elementName: string;
+        /** @deprecated Use elementName instead */
+        tableName: string;
+        schemaName: string | null;
+    };
+}
+export interface TablePartial {
+    name: string;
+    fields: Column[];
+    token: TokenPosition;
+    indexes: Index[];
+    checks: Check[];
+    headerColor?: string;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface TablePartialInjection {
+    name: string;
+    order: number;
+    token: TokenPosition;
+}
+export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
+export interface RecordValue {
+    value: any;
+    type: RecordValueType;
+}
+export interface TableRecord {
+    schemaName: string | undefined;
+    tableName: string;
+    columns: string[];
+    values: RecordValue[][];
+    token: TokenPosition;
+}
+export type Project = Record<string, never> | {
+    name: string | null;
+    tables: Table[];
+    refs: Ref[];
+    enums: Enum[];
+    tableGroups: TableGroup[];
+    tablePartials: TablePartial[];
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+    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 | Ref | RefEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue;

package/dist/src/core/{analyzer → types}/symbol/factory.d.ts

@@ -1,4 +1,4 @@
-import { NodeSymbol, NodeSymbolId, NodeSymbolIdGenerator } from './symbols';
+import { NodeSymbol, NodeSymbolId, NodeSymbolIdGenerator } from '.';
 export default class SymbolFactory {
     private generator;
     constructor(generator: NodeSymbolIdGenerator);

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

@@ -0,0 +1,5 @@
+export * from './symbols';
+export * from './symbolIndex';
+export * from './symbolTable';
+export * from './utils';
+export { default as SymbolFactory, } from './factory';

package/dist/src/core/{analyzer → types}/symbol/symbolIndex.d.ts

@@ -1,4 +1,3 @@
-import { Option } from '../../option';
 export type NodeSymbolIndex = string;
 export declare enum SymbolKind {
     Schema = "Schema",
@@ -8,7 +7,7 @@ export declare enum SymbolKind {
     TableGroupField = "TableGroup field",
     Enum = "Enum",
     EnumField = "Enum field",
-    Note = "Note",
+    StickyNote = "Note",
     TablePartial = "TablePartial",
     PartialInjection = "PartialInjection",
     DiagramView = "DiagramView",
@@ -27,8 +26,8 @@ export declare function createPartialInjectionSymbolIndex(key: string): NodeSymb
 export declare function createDiagramViewSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createDiagramViewFieldSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createNodeSymbolIndex(key: string, symbolKind: SymbolKind): NodeSymbolIndex;
-export declare function destructureIndex(id: NodeSymbolIndex): Option<{
+export declare function destructureIndex(id: NodeSymbolIndex): {
     name: string;
     kind: SymbolKind;
-}>;
+} | undefined;
 export declare function isPublicSchemaIndex(id: NodeSymbolIndex): boolean;