@dbml/parse 7.0.0 → 7.0.1-alpha.0

package/dist/__tests__/utils/arbitraries/utils.d.ts

@@ -1,59 +0,0 @@
-import { default as fc } from 'fast-check';
-export declare function orRegex(...subregexes: RegExp[]): RegExp;
-export declare function chainRegex(...subregexes: RegExp[]): RegExp;
-export declare function matchFullRegex(regex: RegExp): RegExp;
-export declare function oneOrManyRegex(regex: RegExp): RegExp;
-export declare function zeroOrManyRegex(regex: RegExp): RegExp;
-/**
- * Helper to generate case variations of a string (lowercase, uppercase, original)
- * Examples:
- *   caseVariant('table') => 'Table' | 'tAble' | 'taBle'
- */
-export declare const caseVariant: (str: string) => fc.Arbitrary<string>;
-/**
- * Helper to generate case variations of one of multiple strings
- * Picks one string from the arguments and varies its case
- * Examples:
- *   caseVariantOneOf('primary key', 'pk') => 'primary key' | 'PRIMARY KEY' | 'pk' | 'PK' | etc.
- */
-export declare const caseVariantOneOf: (...strings: string[]) => fc.Arbitrary<string>;
-/**
- * Helper to generate case variations with key:value format for settings
- */
-export declare const settingKeyValue: (key: string, valueArb: fc.Arbitrary<string>) => fc.Arbitrary<string>;
-/**
- * Helper to generate random whitespace (spaces, tabs, newlines)
- * CRLF tested separately via crlfSchemaArbitrary
- */
-export declare const randomSpaceArbitrary: fc.Arbitrary<string>;
-/**
- * Helper to generate random inline whitespace (spaces and tabs only, NO newlines)
- * Returns 1-3 whitespace characters
- * Use this for single-line constructs (columns, enum values, checks, indexes)
- */
-export declare const randomInlineSpaceArbitrary: fc.Arbitrary<string>;
-/**
- * Helper to join string/arbitrary tokens with random spacing between them
- * Automatically injects random whitespace between all tokens (including newlines)
- * Use this for top-level declarations (Table, Enum, Ref, etc.)
- *
- * @param tokens - Array of strings or arbitraries to join
- * @returns An arbitrary that produces the joined string with random spacing
- *
- * @example
- * joinWithRandomSpaces(caseVariant('Table'), 'users', '{')
- * // Produces: "Table  users {" or "TABLE\n\tusers\t{" etc.
- */
-export declare const joinWithRandomSpaces: (...tokens: (fc.Arbitrary<string> | string)[]) => fc.Arbitrary<string>;
-/**
- * Helper to join string/arbitrary tokens with random inline spacing (NO newlines)
- * Use this for single-line constructs (columns, enum values, checks, indexes)
- *
- * @param tokens - Array of strings or arbitraries to join
- * @returns An arbitrary that produces the joined string with random inline spacing
- *
- * @example
- * joinWithRandomInlineSpaces('id', 'int', '[pk]')
- * // Produces: "id  int [pk]" or "id\tint\t\t[pk]" etc. (no newlines)
- */
-export declare const joinWithRandomInlineSpaces: (...tokens: (fc.Arbitrary<string> | string)[]) => fc.Arbitrary<string>;

package/dist/__tests__/utils/compiler.d.ts

@@ -1,13 +0,0 @@
-import { ProgramNode, SyntaxNode } from '../../src/core/parser/nodes';
-import { default as Report } from '../../src/core/report';
-import { SyntaxToken } from '../../src/index';
-import { Database } from '../../src/core/interpreter/types';
-export declare function lex(source: string): Report<SyntaxToken[]>;
-export declare function parse(source: string): Report<{
-    ast: ProgramNode;
-    tokens: SyntaxToken[];
-}>;
-export declare function analyze(source: string): Report<ProgramNode>;
-export declare function interpret(source: string): Report<Database | undefined>;
-export declare function flattenTokens(token: SyntaxToken): SyntaxToken[];
-export declare function print(source: string, ast: SyntaxNode): string;

package/dist/__tests__/utils/index.d.ts

@@ -1,3 +0,0 @@
-export { createPosition, MockTextModel, createMockTextModel, extractTextFromRange, } from './mocks';
-export { scanTestNames, serialize, } from './testHelpers';
-export { lex, parse, analyze, interpret, flattenTokens, print, } from './compiler';

package/dist/__tests__/utils/mocks.d.ts

@@ -1,17 +0,0 @@
-import { Position, TextModel } from '../../src/services';
-export declare function createPosition(lineNumber: number, column: number): Position;
-export declare class MockTextModel {
-    private content;
-    uri: any;
-    constructor(content: string, uri?: string);
-    getOffsetAt(position: Position): number;
-    getValue(): string;
-    getLineContent(lineNumber: number): string;
-}
-export declare function createMockTextModel(content: string, uri?: string): TextModel;
-export declare function extractTextFromRange(program: string, range: {
-    startLineNumber: number;
-    startColumn: number;
-    endLineNumber: number;
-    endColumn: number;
-}): string;

package/dist/__tests__/utils/testHelpers.d.ts

@@ -1,16 +0,0 @@
-import { default as Report } from '../../src/core/report';
-import { ProgramNode } from '../../src/index';
-export declare function scanTestNames(_path: any): string[];
-/**
- * Serializes a compiler report to JSON, handling circular references and
- * reducing verbosity by outputting IDs instead of full objects where appropriate.
- *
- * The serializer handles special keys:
- * - 'symbol': For non-root nodes, outputs only the symbol ID. For root nodes,
- *   outputs the full symbol table with references as IDs.
- * - 'referee': Outputs only the referenced symbol's ID
- * - 'parent': Outputs only the parent node's ID
- * - 'declaration': Outputs only the declaration node's ID
- * - 'symbolTable': Converts Map to Object for JSON compatibility
- */
-export declare function serialize(report: Readonly<Report<ProgramNode>>, pretty?: boolean): string;

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

@@ -1,132 +0,0 @@
-import { default as SymbolTable } from './symbolTable';
-import { SyntaxNode } from '../../parser/nodes';
-export type NodeSymbolId = number;
-export declare class NodeSymbolIdGenerator {
-    private id;
-    reset(): void;
-    nextId(): NodeSymbolId;
-}
-export interface NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable?: SymbolTable;
-    declaration?: SyntaxNode;
-    references: SyntaxNode[];
-}
-export declare class SchemaSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    references: SyntaxNode[];
-    constructor({ symbolTable }: {
-        symbolTable: SymbolTable;
-    }, id: NodeSymbolId);
-}
-export declare class EnumSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class EnumFieldSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ declaration }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TableSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class ColumnSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ declaration }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TableGroupSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TableGroupFieldSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ declaration }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class DiagramViewSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class DiagramViewFieldSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ declaration }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class StickyNoteSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ declaration }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TablePartialSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class PartialInjectionSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ symbolTable, declaration }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TablePartialInjectedColumnSymbol implements NodeSymbol {
-    id: NodeSymbolId;
-    declaration: SyntaxNode;
-    tablePartialSymbol: TablePartialSymbol;
-    references: SyntaxNode[];
-    constructor({ declaration, tablePartialSymbol }: {
-        declaration: SyntaxNode;
-        tablePartialSymbol: TablePartialSymbol;
-    }, id: NodeSymbolId);
-}

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

@@ -1,18 +0,0 @@
-export type Option<T> = Some<T> | None<T>;
-export declare class Some<T> {
-    value: T;
-    constructor(value: T);
-    unwrap(): T;
-    unwrap_or<S>(orValue: S): S | T;
-    and_then<S>(callback: (_: T) => Option<S>): Option<S>;
-    map<S>(callback: (_: T) => S): Option<S>;
-    isOk(): boolean;
-}
-export declare class None<T> {
-    value: undefined;
-    unwrap(): T;
-    unwrap_or<S>(orValue: S): S | T;
-    and_then<S>(callback: (_: T) => Option<S>): Option<S>;
-    map<S>(callback: (_: T) => S): Option<S>;
-    isOk(): boolean;
-}

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

@@ -1,12 +0,0 @@
-import { CompileError, CompileWarning } from './errors';
-export default class Report<T> {
-    private value;
-    private errors;
-    private warnings?;
-    constructor(value: T, errors?: CompileError[], warnings?: CompileWarning[]);
-    getValue(): T;
-    getErrors(): CompileError[];
-    getWarnings(): CompileWarning[];
-    chain<U>(fn: (_: T) => Report<U>): Report<U>;
-    map<U>(fn: (_: T) => U): Report<U>;
-}

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

@@ -1,13 +0,0 @@
-import { SyntaxToken } from './lexer/tokens';
-import { PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode } from './parser/nodes';
-export declare function isAlphaOrUnderscore(char: string): boolean;
-export declare function isDigit(char: string): boolean;
-export declare function isHexChar(char: string): boolean;
-export declare function isAlphaNumeric(char: string): boolean;
-export declare function alternateLists<T, S>(firstList: T[], secondList: S[]): (T | S)[];
-export declare function isOffsetWithinFullSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
-export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
-export declare function returnIfIsOffsetWithinFullSpan(offset: number, node?: SyntaxNode): SyntaxNode | undefined;
-export declare function returnIfIsOffsetWithinFullSpan(offset: number, token?: SyntaxToken): SyntaxToken | undefined;
-export declare function getNumberTextFromExpression(node: PrimaryExpressionNode | PrefixExpressionNode): string;
-export declare function parseNumber(node: PrefixExpressionNode | PrimaryExpressionNode): number;