@atscript/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,566 @@
+interface TLexicalToken {
+    type: 'annotation' | 'comment' | 'punctuation' | 'identifier' | 'text' | 'number' | 'block' | 'unknown';
+    text: string;
+    children?: TLexicalToken[];
+    startOffset?: number;
+    endOffset?: number;
+    accepted?: boolean;
+    multiline?: boolean;
+    getRange: () => {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+
+declare class Token {
+    protected readonly _data: TLexicalToken;
+    constructor(_data: TLexicalToken);
+    toString(): string;
+    clone(replace: Partial<TLexicalToken>): Token;
+    get text(): string;
+    get type(): "number" | "annotation" | "comment" | "punctuation" | "identifier" | "text" | "block" | "unknown";
+    get range(): {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    get children(): TLexicalToken[];
+    get hasChildren(): boolean;
+    get multiline(): boolean | undefined;
+    fromPath?: string;
+    exported?: boolean;
+    isDefinition?: boolean;
+    isReference?: boolean;
+    imported?: boolean;
+    isProp?: boolean;
+    isChain?: boolean;
+    parentNode?: SemanticNode;
+    get isAnnotation(): boolean;
+    annotationRef?: Token;
+    index?: number;
+    blockType?: 'structure' | 'type' | 'import';
+}
+
+interface TPluginManagers {
+    manager: PluginManager;
+    file?: string;
+    dependants: Set<string>;
+}
+declare class AtscriptRepo {
+    readonly root: string;
+    readonly sharedConfig?: TAtscriptConfigInput | undefined;
+    constructor(root?: string, sharedConfig?: TAtscriptConfigInput | undefined);
+    protected configFormat?: 'esm' | 'cjs';
+    protected readonly configs: Map<string, Promise<TPluginManagers>>;
+    protected readonly atscripts: Map<string, Promise<AtscriptDoc>>;
+    sharedPluginManager: TPluginManagers | undefined;
+    protected configFiles: Map<string, Promise<Partial<TAtscriptConfigInput & TAtscriptConfigOutput>>>;
+    getSharedPluginManager(): PluginManager | undefined;
+    getPrimitivesTags(): Promise<Set<string> | undefined>;
+    getUsedAnnotations(): Promise<Record<string, {
+        multiple?: boolean;
+        fromSpec?: boolean;
+        typeSet: Set<string>;
+        types: ({
+            type: "object";
+            props: Record<string, {
+                optional?: boolean;
+                type: "string" | "number" | "boolean" | "unknown";
+            }>;
+        } | {
+            optional?: boolean;
+            type: "string" | "number" | "boolean" | "unknown";
+        })[];
+    } | undefined>>;
+    loadPluginManagerFor(id: string): Promise<TPluginManagers>;
+    resolveConfig(id: string): Promise<TPluginManagers>;
+    openDocument(id: string, text?: string): Promise<AtscriptDoc>;
+    protected _openDocument(id: string, text?: string): Promise<AtscriptDoc>;
+    checkDoc(atscript: AtscriptDoc): Promise<void>;
+    checkImports(atscript: AtscriptDoc): Promise<void>;
+    checkImport(atscript: AtscriptDoc, from: Token, imports: Token[]): Promise<AtscriptDoc | undefined>;
+}
+
+type TPunctuation = '\n' | '&' | '+' | ',' | '\\' | '-' | '.' | '/' | ':' | '=' | '?' | '|' | ';';
+
+declare enum TSeverity {
+    Error = 1,
+    Warning = 2,
+    Info = 3,
+    Hint = 4
+}
+type TMessages = Array<{
+    severity: TSeverity;
+    message: string;
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    tags?: Array<1 | 2>;
+}>;
+
+interface TOutput extends TOutputWithSource {
+    target: string;
+}
+declare function build(config: Partial<TAtscriptConfigInput>): Promise<BuildRepo>;
+declare class BuildRepo {
+    private readonly rootDir;
+    private readonly repo;
+    private readonly docs;
+    constructor(rootDir: string, repo: AtscriptRepo, docs: AtscriptDoc[]);
+    diagnostics(): Promise<Map<string, TMessages>>;
+    generate(config: TAtscriptConfigOutput, docs?: AtscriptDoc[]): Promise<TOutput[]>;
+    write(config: TAtscriptConfigOutput, docs?: AtscriptDoc[]): Promise<TOutput[]>;
+}
+
+interface TPluginOutput {
+    fileName: string;
+    content: string;
+}
+type TAtscriptRenderFormat = string;
+interface TAtscriptPlugin {
+    name: string;
+    config?: (config: TAtscriptConfig) => Promise<TAtscriptConfig | undefined> | TAtscriptConfig | undefined;
+    resolve?: (id: string) => Promise<string | undefined> | string | undefined;
+    load?: (id: string) => Promise<string | undefined> | string | undefined;
+    onDocumnet?: (doc: AtscriptDoc) => Promise<void> | void;
+    render?: (doc: AtscriptDoc, format: TAtscriptRenderFormat) => Promise<TPluginOutput[]> | TPluginOutput[];
+    buildEnd?: (output: TOutput[], format: TAtscriptRenderFormat, repo: AtscriptRepo) => Promise<void> | void;
+}
+declare const createAtscriptPlugin: (plugin: TAtscriptPlugin) => TAtscriptPlugin;
+
+interface TOutputWithSource extends TPluginOutput {
+    source: string;
+}
+declare class PluginManager {
+    private readonly cfg;
+    constructor(cfg: TAtscriptConfig);
+    private _config;
+    name: string;
+    protected _docConfig: TAtscriptDocConfig | undefined;
+    get plugins(): TAtscriptPlugin[];
+    getDocConfig(): Promise<TAtscriptDocConfig>;
+    config(config?: TAtscriptConfig): Promise<TAtscriptConfig>;
+    resolve(id: string): Promise<string | undefined>;
+    load(id: string): Promise<string>;
+    onDocumnet(doc: AtscriptDoc): Promise<void>;
+    render(doc: AtscriptDoc, format: TAtscriptRenderFormat): Promise<TOutputWithSource[]>;
+    buildEnd(output: TOutput[], format: TAtscriptRenderFormat, repo: AtscriptRepo): Promise<void>;
+    loopInAnnotationsSpec(cb: (name: string, a: AnnotationSpec) => void): Promise<void>;
+    private _loopInAnnotationsSpec;
+}
+
+declare class IdRegistry {
+    readonly reserved: Set<string>;
+    readonly globalTypes: Set<string>;
+    readonly definitions: Map<string, Token>;
+    readonly duplicates: Set<Token>;
+    readonly forbidden: Set<Token>;
+    constructor(globalTypes?: string[]);
+    clear(): void;
+    registerDefinition(token?: Token): void;
+    isDefined(t: string | Token): boolean;
+    getErrors(): TMessages;
+}
+
+type TSemanticToken = 'type' | 'identifier' | 'array' | 'export' | 'optional' | 'inner' | 'path' | 'from';
+type TNodeEntity = 'interface' | 'type' | 'ref' | 'const' | 'prop' | 'structure' | 'tuple' | 'group' | 'array' | 'import' | 'primitive';
+interface TAnnotationTokens {
+    name: string;
+    token: Token;
+    args: Token[];
+}
+interface TPrimitiveBaseConfig {
+    type?: TPrimitiveTypeDef;
+    documentation?: string;
+    tags?: string[];
+    expect?: {
+        min?: number;
+        max?: number;
+        int?: boolean;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string | RegExp | (string | RegExp)[];
+        message?: string;
+    };
+}
+interface TPrimitiveConfig extends TPrimitiveBaseConfig {
+    extensions?: {
+        [name: string]: Partial<TPrimitiveConfig>;
+    };
+}
+interface TPrimitiveTypeComplex {
+    kind: 'union' | 'intersection' | 'tuple';
+    items: TPrimitiveTypeDef[];
+    optional?: boolean;
+}
+interface TPrimitiveTypeArray {
+    kind: 'array';
+    of: TPrimitiveTypeDef;
+    optional?: boolean;
+}
+interface TPrimitiveTypeObject {
+    kind: 'object';
+    props: Record<string, TPrimitiveTypeDef>;
+    optional?: boolean;
+}
+type TPrimitiveTypeFinal = 'string' | 'number' | 'boolean' | 'void' | 'null';
+type TPrimitiveTypeFinalOptional = {
+    kind: 'final';
+    value: TPrimitiveTypeFinal;
+    optional: true;
+};
+type TPrimitiveTypeDef = TPrimitiveTypeComplex | TPrimitiveTypeArray | TPrimitiveTypeObject | TPrimitiveTypeFinal | TPrimitiveTypeFinalOptional;
+
+declare class SemanticPrimitiveNode extends SemanticNode {
+    private readonly _id;
+    readonly config: TPrimitiveConfig;
+    private readonly parentKey;
+    constructor(_id: string, config: TPrimitiveConfig, parentKey?: string);
+    protected applyAnnotations(): void;
+    readonly type?: 'union' | 'intersection' | 'tuple' | 'array' | 'object' | 'string' | 'number' | 'boolean' | 'void' | 'null';
+    get key(): string;
+    getAllTags(_processed?: Set<SemanticPrimitiveNode>): string[];
+    get id(): string;
+    get documentation(): string;
+    readonly props: Map<string, SemanticPrimitiveNode>;
+    readonly tags: Set<string>;
+    toString(level?: number, prefix?: string): string;
+}
+
+interface ITokensIndex {
+    add: (token: Token) => void;
+    at: (line: number, character: number) => Token | undefined;
+    before: (line: number, character: number) => Token | undefined;
+}
+
+interface TAtscriptDocConfig {
+    primitives?: Map<string, SemanticPrimitiveNode>;
+    annotations?: TAnnotationsTree;
+    unknownAnnotation?: 'allow' | 'warn' | 'error';
+    plugins?: TAtscriptPlugin[];
+}
+declare class AtscriptDoc {
+    readonly id: string;
+    readonly config: TAtscriptDocConfig;
+    private readonly manager?;
+    constructor(id: string, config: TAtscriptDocConfig, manager?: PluginManager | undefined);
+    get name(): string | undefined;
+    readonly registry: IdRegistry;
+    semanticMessages: TMessages;
+    messages: TMessages;
+    tokensIndex: ITokensIndex;
+    blocksIndex: ITokensIndex;
+    imports: Map<string, {
+        from: Token;
+        imports: Token[];
+    }>;
+    importedDefs: Map<string, Token>;
+    readonly exports: Map<string, SemanticNode>;
+    readonly dependencies: Set<AtscriptDoc>;
+    readonly dependants: Set<AtscriptDoc>;
+    referred: Token[];
+    readonly dependenciesMap: Map<string, AtscriptDoc>;
+    get primitives(): SemanticPrimitiveNode[];
+    render(format: TAtscriptRenderFormat): Promise<TOutputWithSource[] | undefined>;
+    resolveAnnotation(name: string): AnnotationSpec | undefined;
+    updateDependencies(docs: AtscriptDoc[]): void;
+    nodes: SemanticNode[];
+    private _text;
+    get text(): string;
+    update(text: string, debug?: boolean): void;
+    cleanup(): void;
+    private registerNodes;
+    resolvedAnnotations: Token[];
+    annotations: TAnnotationTokens[];
+    registerAnnotation(annotationTokens: TAnnotationTokens): void;
+    unwindType(name: string, chain?: string[] | Token[], watchCb?: (def: SemanticNode) => void, _tracked?: Set<SemanticNode>): {
+        doc: AtscriptDoc;
+        node?: SemanticNode;
+        def: SemanticNode;
+    } | undefined;
+    getUsageListAt(line: number, character: number): {
+        uri: string;
+        range: Token["range"];
+        token: Token;
+    }[] | undefined;
+    evalAnnotationsForNode(givenNode: SemanticNode): TAnnotationTokens[] | undefined;
+    usageListFor(token: Token): Array<{
+        uri: string;
+        range: Token['range'];
+        token: Token;
+    }> | undefined;
+    getDefinitionFor(token: Token): {
+        uri: string;
+        doc?: AtscriptDoc;
+        token?: Token;
+    } | undefined;
+    getToDefinitionAt(line: number, character: number): {
+        targetUri: string;
+        targetRange: {
+            start: {
+                line: number;
+                character: number;
+            };
+            end: {
+                line: number;
+                character: number;
+            };
+        };
+        targetSelectionRange: {
+            start: {
+                line: number;
+                character: number;
+            };
+            end: {
+                line: number;
+                character: number;
+            };
+        };
+        originSelectionRange: {
+            start: {
+                line: number;
+                character: number;
+            };
+            end: {
+                line: number;
+                character: number;
+            };
+        };
+    }[] | undefined;
+    registerImport({ from, imports, block }: {
+        from: Token;
+        imports: Token[];
+        block: Token;
+    }): void;
+    registerDefinition(token?: Token, asImport?: boolean): void;
+    getDeclarationOwnerNode(identifier: string): {
+        doc: AtscriptDoc;
+        node?: SemanticNode;
+        token?: Token;
+    } | undefined;
+    registerExport(node: SemanticNode): void;
+    registerMessage(token: Token, message: string, severity?: TSeverity, tag?: 'dim' | 'crossed'): void;
+    registerMessages(messages?: TMessages): void;
+    private _allMessages;
+    clearMessages(): void;
+    getUnusedTokens(): Token[];
+    getDiagMessages(): TMessages;
+    mergeIntersection(node: SemanticNode): SemanticNode;
+    mergeDefs(_left: SemanticNode, _right: SemanticNode): [SemanticNode] | [SemanticNode, SemanticNode];
+    mergeNodesAnnotations(left?: TAnnotationTokens[], right?: TAnnotationTokens[]): TAnnotationTokens[];
+}
+
+declare class SemanticNode {
+    entity: TNodeEntity;
+    constructor(entity: TNodeEntity);
+    protected tokens?: Map<TSemanticToken, Token>;
+    protected isGroup: boolean;
+    protected definition?: SemanticNode;
+    annotations?: TAnnotationTokens[];
+    annotationsCounter?: Map<string, number>;
+    registerAtDocument(doc: AtscriptDoc): void;
+    protected _documentation?: string;
+    setDocumentation(s: string): void;
+    get documentation(): string | undefined;
+    get id(): string | undefined;
+    get referredIdentifiers(): Token[];
+    getIdentifiersRecursive(node: SemanticNode): Token[];
+    countAnnotations(name: string): number;
+    annotate(name: string, token: Token): (arg: Token) => void;
+    get length(): number;
+    define(node: SemanticNode): this;
+    get def(): SemanticNode | undefined;
+    get identifier(): string | undefined;
+    saveToken(token: Token, semantic: TSemanticToken): this;
+    wrap(node: SemanticNode, token: Token): this;
+    token(s: TSemanticToken): Token | undefined;
+    has(s: TSemanticToken): boolean | undefined;
+    toString(level?: number, prefix?: string): string;
+    renderAnnotations(): string;
+    protected renderChildren(): string;
+    getDefinition(): SemanticNode | undefined;
+}
+
+declare class SemanticArrayNode extends SemanticNode {
+    constructor();
+    get props(): Map<string, SemanticNode>;
+}
+
+declare class SemanticConstNode extends SemanticNode {
+    constructor();
+    registerAtDocument(doc: AtscriptDoc): void;
+}
+
+declare class SemanticGroup extends SemanticNode {
+    protected nodes: SemanticNode[];
+    private operator?;
+    isGroup: boolean;
+    constructor(nodes?: SemanticNode[], operator?: TPunctuation | undefined);
+    registerAtDocument(doc: AtscriptDoc): void;
+    get length(): number;
+    get first(): SemanticNode;
+    get op(): TPunctuation | undefined;
+    define(node: SemanticNode): this;
+    wrap(node: SemanticNode, token: Token): this;
+    unwrap(): SemanticNode[];
+    protected renderChildren(): string;
+}
+
+declare class SemanticImportNode extends SemanticNode {
+    constructor();
+    registerAtDocument(doc: AtscriptDoc): void;
+}
+
+declare class SemanticRefNode extends SemanticNode {
+    constructor();
+    get referredIdentifiers(): Token[];
+    protected _chain: Token[];
+    protected _dots: Token[];
+    registerAtDocument(doc: AtscriptDoc): void;
+    addChain(token: Token): void;
+    addDot(token: Token): void;
+    get chain(): Token[];
+    get hasChain(): boolean;
+    toString(level?: number, prefix?: string): string;
+}
+
+declare class SemanticPropNode extends SemanticNode {
+    constructor();
+    registerAtDocument(doc: AtscriptDoc): void;
+    get nestedProps(): Map<string, SemanticPropNode> | undefined;
+    get nestedType(): SemanticRefNode | undefined;
+}
+
+declare class SemanticInterfaceNode extends SemanticNode {
+    constructor();
+    registerAtDocument(doc: AtscriptDoc): void;
+    get props(): Map<string, SemanticPropNode>;
+}
+
+declare class SemanticStructureNode extends SemanticGroup {
+    constructor();
+    readonly props: Map<string, SemanticPropNode>;
+    setProps(props: SemanticPropNode[]): void;
+    registerAtDocument(doc: AtscriptDoc): void;
+    addVirtualProp(opts: {
+        name: string;
+        type: string | SemanticNode;
+        documentation?: string;
+        refToken?: Token;
+    }): void;
+}
+
+declare class SemanticTupleNode extends SemanticGroup {
+    constructor();
+}
+
+declare class SemanticTypeNode extends SemanticNode {
+    constructor();
+    registerAtDocument(doc: AtscriptDoc): void;
+}
+
+declare const $n: {
+    SemanticGroup: typeof SemanticGroup;
+    SemanticInterfaceNode: typeof SemanticInterfaceNode;
+    SemanticTypeNode: typeof SemanticTypeNode;
+    SemanticRefNode: typeof SemanticRefNode;
+    SemanticConstNode: typeof SemanticConstNode;
+    SemanticPropNode: typeof SemanticPropNode;
+    SemanticStructureNode: typeof SemanticStructureNode;
+    SemanticTupleNode: typeof SemanticTupleNode;
+    SemanticArrayNode: typeof SemanticArrayNode;
+    SemanticImportNode: typeof SemanticImportNode;
+    SemanticPrimitiveNode: typeof SemanticPrimitiveNode;
+};
+
+declare function isGroup(node?: SemanticNode): node is SemanticGroup;
+declare function isInterface(node?: SemanticNode): node is SemanticInterfaceNode;
+declare function isType(node?: SemanticNode): node is SemanticTypeNode;
+declare function isRef(node?: SemanticNode): node is SemanticRefNode;
+declare function isConst(node?: SemanticNode): node is SemanticConstNode;
+declare function isProp(node?: SemanticNode): node is SemanticPropNode;
+declare function isStructure(node?: SemanticNode): node is SemanticStructureNode;
+declare function isTuple(node?: SemanticNode): node is SemanticTupleNode;
+declare function isArray(node?: SemanticNode): node is SemanticArrayNode;
+declare function isImport(node?: SemanticNode): node is SemanticImportNode;
+declare function isPrimitive(node?: SemanticNode): node is SemanticPrimitiveNode;
+
+interface TAtscriptConfigInput {
+    rootDir: string;
+    entries?: string[];
+    primitives?: Record<string, TPrimitiveConfig>;
+    annotations?: TAnnotationsTree;
+    unknownAnnotation?: 'allow' | 'warn' | 'error';
+    plugins?: TAtscriptPlugin[];
+    include?: string[];
+    exclude?: string[];
+}
+interface TAtscriptConfigOutput {
+    format: TAtscriptRenderFormat;
+    outDir?: string;
+}
+type TAtscriptConfig = Partial<TAtscriptConfigInput & TAtscriptConfigOutput>;
+interface TAnnotationsTree {
+    [key: string]: AnnotationSpec | TAnnotationsTree;
+}
+
+declare function defineConfig(config: TAtscriptConfig): TAtscriptConfig;
+
+declare function resolveConfigFile(docUri: string, _root?: string): Promise<string | undefined>;
+declare function loadTsConfig(configFile: string, forceFormat?: 'cjs' | 'esm'): Promise<TAtscriptConfig>;
+declare function loadConfig(configPath: string, forceFormat?: 'cjs' | 'esm'): Promise<TAtscriptConfig>;
+
+interface TAnnotationArgument {
+    optional?: boolean;
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description?: string;
+    values?: string[];
+}
+interface TAnnotationSpecConfig {
+    multiple?: boolean;
+    mergeStrategy?: 'append' | 'replace';
+    description?: string;
+    nodeType?: TNodeEntity[];
+    defType?: SemanticPrimitiveNode['type'][];
+    argument?: TAnnotationArgument[] | TAnnotationArgument;
+    validate?: (mainToken: Token, args: Token[], doc: AtscriptDoc) => TMessages | undefined;
+    modify?: (mainToken: Token, args: Token[], doc: AtscriptDoc) => void;
+}
+declare class AnnotationSpec {
+    readonly config: TAnnotationSpecConfig;
+    readonly __is_annotation_spec = true;
+    constructor(config: TAnnotationSpecConfig);
+    get arguments(): TAnnotationArgument[];
+    get argumentsSnippet(): string;
+    private validateType;
+    modify(mainToken: Token, args: Token[], doc: AtscriptDoc): void;
+    validate(mainToken: Token, args: Token[], doc: AtscriptDoc): TMessages | undefined;
+    renderDocs(index: number | string): string | undefined;
+    protected getDefaultValueForType(name: string, type: 'string' | 'number' | 'boolean'): string;
+}
+declare function isAnnotationSpec(a?: TAnnotationsTree | AnnotationSpec): a is AnnotationSpec;
+declare function resolveAnnotation(name: string, annotationsTree?: TAnnotationsTree): AnnotationSpec | undefined;
+
+declare function resolveAtscriptFromPath(from: string, id: string): string;
+declare function getRelPath(fromUri: string, toUri: string): string;
+
+export { $n, AnnotationSpec, AtscriptDoc, AtscriptRepo, BuildRepo, PluginManager, SemanticArrayNode, SemanticConstNode, SemanticGroup, SemanticImportNode, SemanticInterfaceNode, SemanticNode, SemanticPrimitiveNode, SemanticPropNode, SemanticRefNode, SemanticStructureNode, SemanticTupleNode, SemanticTypeNode, type TAnnotationArgument, type TAnnotationSpecConfig, type TAnnotationTokens, type TAnnotationsTree, type TAtscriptConfig, type TAtscriptConfigInput, type TAtscriptConfigOutput, type TAtscriptDocConfig, type TAtscriptPlugin, type TAtscriptRenderFormat, type TMessages, type TNodeEntity, type TOutput, type TOutputWithSource, type TPluginOutput, type TPrimitiveBaseConfig, type TPrimitiveConfig, type TPrimitiveTypeArray, type TPrimitiveTypeComplex, type TPrimitiveTypeDef, type TPrimitiveTypeFinal, type TPrimitiveTypeFinalOptional, type TPrimitiveTypeObject, type TSemanticToken, Token, build, createAtscriptPlugin, defineConfig, getRelPath, isAnnotationSpec, isArray, isConst, isGroup, isImport, isInterface, isPrimitive, isProp, isRef, isStructure, isTuple, isType, loadConfig, loadTsConfig, resolveAnnotation, resolveAtscriptFromPath, resolveConfigFile };