karakum 1.0.0-alpha.9 → 1.0.0-alpha.90

package/README.md

@@ -1,3 +1,10 @@
+[![GitHub Licence](https://img.shields.io/github/license/karakum-team/karakum)](https://github.com/karakum-team/karakum/blob/master/LICENSE)
+[![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/karakum-team/karakum/ci.yml)](https://github.com/karakum-team/karakum/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/karakum)](https://www.npmjs.com/package/karakum)
+[![Maven Central](https://img.shields.io/maven-central/v/io.github.sgrishchenko/karakum)](https://central.sonatype.com/artifact/io.github.sgrishchenko/karakum)
+[![Gradle Plugin Portal](https://img.shields.io/gradle-plugin-portal/v/io.github.sgrishchenko.karakum)](https://plugins.gradle.org/plugin/io.github.sgrishchenko.karakum)
+
+
 # Karakum
 
 Converter of TypeScript declaration files to Kotlin declarations.
@@ -14,7 +21,7 @@ Gradle plugin for Kotlin Gradle projects:
 
 ```kotlin
 plugins {
-    id("io.github.sgrishchenko.karakum") version "1.0.0-alpha.9"
+    id("io.github.sgrishchenko.karakum") version "1.0.0-alpha.90"
 }
 ```
 

package/kotlin/karakum-bin.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {cli} from "./karakum.mjs"
+
+await cli()

package/kotlin/karakum-types.d.ts

@@ -0,0 +1,55 @@
+import {
+    CompilerOptions,
+    Program,
+    SourceFile,
+    CommentRange,
+    Symbol as TsSymbol,
+
+    Declaration,
+    NamedDeclaration,
+    ModuleDeclaration,
+    ParameterDeclaration,
+    TypeParameterDeclaration,
+    SignatureDeclarationBase,
+
+    Node,
+    TypeNode,
+    UnionTypeNode,
+    TypeReferenceNode,
+
+    HeritageClause
+} from "typescript"
+
+type Symbol = symbol
+export type Many<T> = T | T[]
+export type ReadonlyRecord<K extends PropertyKey, V> = Readonly<Record<K, V>>
+export type Rule = string | ReadonlyRecord<string, string>
+export type Tuple2<A, B> = [A, B]
+
+export type Granularity = "bundle" | "file" | "top-level"
+export type NamespaceStrategy = "ignore" | "object" | "package"
+export type ConflictResolutionStrategy = "join" | "replace" | "error"
+export type InputResolutionStrategy = "node" | "plain"
+
+export type ParameterDeclarationStrategy = "function" | "lambda"
+
+export type AnonymousDeclaration = string | {
+    name: string,
+    declaration: string,
+    reference: string,
+}
+
+export type InjectionType =
+    | "MEMBER"
+    | "STATIC_MEMBER"
+
+    | "PARAMETER"
+    | "TYPE_PARAMETER"
+
+    | "HERITAGE_CLAUSE"
+
+export type Render<TNode extends Node> = (node: TNode) => string
+
+export declare interface UnionService {
+    readonly uncoveredUnionParents: Map<TsSymbol, Array<string>>
+}

package/kotlin/karakum.d.mts

@@ -0,0 +1,409 @@
+import {
+    CompilerOptions,
+    Program,
+    SourceFile,
+    CommentRange,
+    Symbol as TsSymbol,
+
+    Declaration,
+    NamedDeclaration,
+    ModuleDeclaration,
+    ParameterDeclaration,
+    TypeParameterDeclaration,
+    SignatureDeclarationBase,
+
+    Node,
+    TypeNode,
+    UnionTypeNode,
+    TypeReferenceNode,
+
+    HeritageClause
+} from "typescript"
+
+type Symbol = symbol
+export type Many<T> = T | T[]
+export type ReadonlyRecord<K extends PropertyKey, V> = Readonly<Record<K, V>>
+export type Rule = string | ReadonlyRecord<string, string>
+export type Tuple2<A, B> = [A, B]
+
+export type Granularity = "bundle" | "file" | "top-level"
+export type NamespaceStrategy = "ignore" | "object" | "package"
+export type ConflictResolutionStrategy = "join" | "replace" | "error"
+export type InputResolutionStrategy = "node" | "plain"
+
+export type ParameterDeclarationStrategy = "function" | "lambda"
+
+export type AnonymousDeclaration = string | {
+    name: string,
+    declaration: string,
+    reference: string,
+}
+
+export type InjectionType =
+    | "MEMBER"
+    | "STATIC_MEMBER"
+
+    | "PARAMETER"
+    | "TYPE_PARAMETER"
+
+    | "HERITAGE_CLAUSE"
+
+export type Render<TNode extends Node> = (node: TNode) => string
+
+export declare interface UnionService {
+    readonly uncoveredUnionParents: Map<TsSymbol, Array<string>>
+}
+
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function cli(): Promise<void>;
+export declare interface SchemaConfiguration {
+    readonly inputRoots?: Nullable<Many<string>>;
+    readonly inputResolutionStrategy?: Nullable<InputResolutionStrategy>;
+    readonly input?: Nullable<Many<string>>;
+    readonly output?: Nullable<string>;
+    readonly ignoreInput?: Nullable<Many<string>>;
+    readonly ignoreOutput?: Nullable<Many<string>>;
+    readonly libraryName?: Nullable<string>;
+    readonly libraryNameOutputPrefix?: Nullable<boolean>;
+    readonly granularity?: Nullable<Granularity>;
+    readonly plugins?: Nullable<Many<any>>;
+    readonly injections?: Nullable<Many<any>>;
+    readonly annotations?: Nullable<Many<any>>;
+    readonly nameResolvers?: Nullable<Many<any>>;
+    readonly inheritanceModifiers?: Nullable<Many<any>>;
+    readonly varianceModifiers?: Nullable<Many<any>>;
+    readonly moduleNameMapper?: Nullable<ReadonlyRecord<string, string>>;
+    readonly packageNameMapper?: Nullable<ReadonlyRecord<string, string>>;
+    readonly importInjector?: Nullable<ReadonlyRecord<string, Array<string>>>;
+    readonly importMapper?: Nullable<any>;
+    readonly namespaceStrategy?: Nullable<ReadonlyRecord<string, NamespaceStrategy>>;
+    readonly conflictResolutionStrategy?: Nullable<ReadonlyRecord<string, ConflictResolutionStrategy>>;
+    readonly compilerOptions?: Nullable<any>;
+    readonly disclaimer?: Nullable<string>;
+    readonly verbose?: Nullable<boolean>;
+    readonly cwd?: Nullable<string>;
+}
+export declare interface PartialConfiguration extends SchemaConfiguration {
+    readonly plugins?: Nullable<Many<Plugin>>;
+    readonly injections?: Nullable<Many<Injection>>;
+    readonly annotations?: Nullable<Many<(p0: Node, p1: AnnotationContext) => Nullable<string>>>;
+    readonly nameResolvers?: Nullable<Many<(p0: Node, p1: Context) => Nullable<string>>>;
+    readonly inheritanceModifiers?: Nullable<Many<(p0: Node, p1: InheritanceModifierContext) => Nullable<string>>>;
+    readonly varianceModifiers?: Nullable<Many<(p0: Node, p1: Context) => Nullable<string>>>;
+    readonly importMapper?: Nullable<Record<string, Rule>>;
+    readonly compilerOptions?: Nullable<CompilerOptions>;
+}
+export declare interface Configuration {
+    readonly inputRoots: Array<string>;
+    readonly inputResolutionStrategy: InputResolutionStrategy;
+    readonly input: Array<string>;
+    readonly inputFileNames: Array<string>;
+    readonly output: string;
+    readonly outputFileName?: Nullable<string>;
+    readonly ignoreInput: Array<string>;
+    readonly ignoreOutput: Array<string>;
+    readonly libraryName: string;
+    readonly libraryNameOutputPrefix: boolean;
+    readonly granularity: Granularity;
+    readonly plugins: Array<Plugin>;
+    readonly injections: Array<Injection>;
+    readonly annotations: Array<(p0: Node, p1: AnnotationContext) => Nullable<string>>;
+    readonly nameResolvers: Array<(p0: Node, p1: Context) => Nullable<string>>;
+    readonly inheritanceModifiers: Array<(p0: Node, p1: InheritanceModifierContext) => Nullable<string>>;
+    readonly varianceModifiers: Array<(p0: Node, p1: Context) => Nullable<string>>;
+    readonly moduleNameMapper: ReadonlyRecord<string, string>;
+    readonly packageNameMapper: ReadonlyRecord<string, string>;
+    readonly importInjector: ReadonlyRecord<string, Array<string>>;
+    readonly importMapper: ReadonlyRecord<string, Rule>;
+    readonly namespaceStrategy: ReadonlyRecord<string, NamespaceStrategy>;
+    readonly conflictResolutionStrategy: ReadonlyRecord<string, ConflictResolutionStrategy>;
+    readonly compilerOptions: CompilerOptions;
+    readonly disclaimer: string;
+    readonly verbose: boolean;
+    readonly cwd: string;
+    readonly inputCwd: string;
+}
+export declare interface AnnotationContext extends Context {
+    readonly isAnonymousDeclaration: boolean;
+}
+export declare interface ContextKey<T extends any> {
+}
+export declare interface Context {
+    registerService<T extends any>(key: ContextKey<T>, service: T): void;
+    lookupService<T extends any>(key: ContextKey<T>): Nullable<T>;
+    requireService<T extends any>(key: ContextKey<T>): T;
+}
+export declare function ContextKey<T extends any>(): ContextKey<T>;
+export declare interface GeneratedFile {
+    readonly fileName: string;
+    readonly body: string;
+}
+export declare interface DerivedFile extends GeneratedFile {
+    readonly package: Array<string>;
+    readonly imports: Array<string>;
+}
+export declare interface InheritanceModifierContext extends Context {
+    readonly signature?: Nullable<Array<ParameterInfo>>;
+    readonly getter?: Nullable<boolean>;
+    readonly setter?: Nullable<boolean>;
+}
+export declare interface InjectionContext extends Context {
+    readonly type: InjectionType;
+}
+export declare interface Injection extends Plugin {
+    inject(node: Node, context: InjectionContext, render: Render<Node>): Nullable<Array<string>>;
+}
+export declare interface Plugin {
+    setup(context: Context): void;
+    traverse(node: Node, context: Context): void;
+    render(node: Node, context: Context, next: Render<Node>): Nullable<string>;
+    generate(context: Context, render: Render<Node>): Array<GeneratedFile>;
+}
+export declare function ifPresent(part: Nullable<string>, render: (p0: string) => string): string;
+export declare function renderNullable(node: Nullable<TypeNode>, isNullable: boolean, context: Context, render: Render<Node>): string;
+export declare function extractTypeParameters(node: Node, context: Context): Array<Tuple2<Node, Declaration>>;
+export declare function renderDeclaration(result: Array<Tuple2<Node, Declaration>>, render: Render<Node>): string;
+export declare function renderReference(result: Array<Tuple2<Node, Declaration>>, render: Render<Node>): string;
+export declare const annotationServiceKey: { get(): ContextKey<AnnotationService>; };
+export declare class AnnotationService {
+    private constructor();
+    resolveAnonymousAnnotations(node: Node, context: Context): Array<string>;
+    resolveAnnotations(node: Node, context: Context): Array<string>;
+}
+export declare namespace AnnotationService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AnnotationService;
+    }
+}
+export declare interface AnonymousDeclarationContext extends Context {
+    resolveName(node: Node): string;
+}
+export declare function createAnonymousDeclarationPlugin(render: (p0: Node, p1: AnonymousDeclarationContext, p2: Render<Node>) => Nullable<AnonymousDeclaration>): Plugin;
+export declare interface CheckCoverageResult {
+    readonly coveredNodes: number;
+    readonly uncoveredNodes: number;
+}
+export declare const checkCoverageServiceKey: { get(): ContextKey<CheckCoverageService>; };
+export declare class CheckCoverageService {
+    private constructor();
+    register(node: Node): void;
+    cover(node: Node): void;
+    deepCover(node: Node): void;
+    emit(callback: (p0: Node) => void): CheckCoverageResult;
+}
+export declare namespace CheckCoverageService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CheckCoverageService;
+    }
+}
+export declare const commentServiceKey: { get(): ContextKey<CommentService>; };
+export declare class CommentService {
+    private constructor();
+    renderLeadingComments(node: Node): Nullable<string>;
+    renderTrailingComments(node: Node): Nullable<string>;
+    renderComments(sourceFile: SourceFile, commentRanges: Array<CommentRange>): string;
+}
+export declare namespace CommentService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CommentService;
+    }
+}
+export declare const configurationServiceKey: { get(): ContextKey<ConfigurationService>; };
+export declare class ConfigurationService {
+    private constructor();
+    get configuration(): Configuration;
+}
+export declare namespace ConfigurationService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ConfigurationService;
+    }
+}
+export declare const declarationMergingServiceKey: { get(): ContextKey<DeclarationMergingService>; };
+export declare class DeclarationMergingService {
+    private constructor();
+    isCovered(node: NamedDeclaration): boolean;
+    cover(node: NamedDeclaration): void;
+    getTypeParameters(node: NamedDeclaration): Nullable<Array<TypeParameterDeclaration>>;
+    getHeritageClauses(node: NamedDeclaration): Nullable<Array<HeritageClause>>;
+    getMembers(node: NamedDeclaration, context: Context): Nullable<Array<NamedDeclaration>>;
+}
+export declare namespace DeclarationMergingService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DeclarationMergingService;
+    }
+}
+export declare const importInfoServiceKey: { get(): ContextKey<ImportInfoService>; };
+export declare class ImportInfoService {
+    private constructor();
+    resolveImports(sourceFileName: string, node: Nullable<ModuleDeclaration>): Array<string>;
+}
+export declare namespace ImportInfoService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ImportInfoService;
+    }
+}
+export declare const inheritanceModifierServiceKey: { get(): ContextKey<InheritanceModifierService>; };
+export declare class InheritanceModifierService {
+    private constructor();
+    resolveSignatureInheritanceModifier(node: Node, signature: Array<ParameterInfo>, context: Context): Nullable<string>;
+    resolveGetterInheritanceModifier(node: Node, context: Context): Nullable<string>;
+    resolveSetterInheritanceModifier(node: Node, context: Context): Nullable<string>;
+    resolveInheritanceModifier(node: Node, context: Context): Nullable<string>;
+}
+export declare namespace InheritanceModifierService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => InheritanceModifierService;
+    }
+}
+export declare const injectionServiceKey: { get(): ContextKey<InjectionService>; };
+export declare class InjectionService {
+    private constructor();
+    resolveInjections(node: Node, type: InjectionType, context: Context, render: Render<Node>): Array<string>;
+}
+export declare namespace InjectionService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => InjectionService;
+    }
+}
+export declare const nameResolverServiceKey: { get(): ContextKey<NameResolverService>; };
+export declare class NameResolverService {
+    private constructor();
+    tryResolveName(node: Node, context: Context): Nullable<string>;
+    resolveName(node: Node, context: Context): string;
+}
+export declare namespace NameResolverService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => NameResolverService;
+    }
+}
+export declare const namespaceInfoServiceKey: { get(): ContextKey<NamespaceInfoService>; };
+export declare class NamespaceInfoService {
+    private constructor();
+    resolveNamespaceStrategy(node: ModuleDeclaration): Nullable<NamespaceStrategy>;
+}
+export declare namespace NamespaceInfoService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => NamespaceInfoService;
+    }
+}
+export declare const typeScriptServiceKey: { get(): ContextKey<TypeScriptService>; };
+export declare class TypeScriptService {
+    private constructor();
+    get program(): Program;
+    printNode(node: Node): string;
+    getParent(node: Node): Nullable<Node>;
+    findClosest(rootNode: Nullable<Node>, predicate: (p0: Node) => boolean): Nullable<Node>;
+    findClosestNamespace(rootNode: Nullable<Node>): Nullable<ModuleDeclaration>;
+    resolveType(node: TypeNode): Nullable<Node>;
+}
+export declare namespace TypeScriptService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => TypeScriptService;
+    }
+}
+export declare const varianceModifierServiceKey: { get(): ContextKey<VarianceModifierService>; };
+export declare class VarianceModifierService {
+    private constructor();
+    resolveVarianceModifier(node: Node, context: Context): Nullable<string>;
+}
+export declare namespace VarianceModifierService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => VarianceModifierService;
+    }
+}
+export declare const unionServiceKey: { get(): ContextKey<UnionService>; };
+export declare class UnionService {
+    private constructor();
+    isCovered(node: NamedDeclaration): boolean;
+    cover(node: NamedDeclaration): void;
+    register(union: UnionTypeNode, reference: TypeReferenceNode): void;
+    getParents(node: NamedDeclaration): Array<string>;
+}
+export declare namespace UnionService {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UnionService;
+    }
+}
+export declare class UnionInjection implements Injection {
+    constructor();
+    setup(context: Context): void;
+    traverse(node: Node, context: Context): void;
+    render(node: Node, context: Context, next: Render<Node>): Nullable<string>;
+    inject(node: Node, context: InjectionContext, render: Render<Node>): Nullable<Array<string>>;
+    generate(context: Context, render: Render<Node>): Array<GeneratedFile>;
+}
+export declare namespace UnionInjection {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UnionInjection;
+    }
+}
+export declare interface ParameterDeclarationsConfiguration {
+    readonly strategy: ParameterDeclarationStrategy;
+    readonly defaultValue?: Nullable<string>;
+    readonly template: (p0: string, p1: Array<ParameterInfo>) => string;
+}
+export declare interface ParameterDeclarationConfiguration {
+    readonly strategy: ParameterDeclarationStrategy;
+    readonly defaultValue?: Nullable<string>;
+    readonly inheritanceModifier?: Nullable<string>;
+    readonly type?: Nullable<TypeNode>;
+    readonly nullable: boolean;
+}
+export declare interface ParameterInfo {
+    readonly parameter: ParameterDeclaration;
+    readonly type?: Nullable<TypeNode>;
+    readonly nullable: boolean;
+    readonly optional: boolean;
+}
+export declare function convertParameterDeclarations(node: SignatureDeclarationBase, context: Context, render: Render<Node>, configuration: ParameterDeclarationsConfiguration): string;
+export declare function convertParameterDeclarationWithFixedType(node: ParameterDeclaration, context: Context, render: Render<Node>, configuration: ParameterDeclarationConfiguration): string;
+export declare function generate(partialConfiguration: PartialConfiguration): Promise<void>;
+export declare function parseArgs(args: Array<string>): Promise<PartialConfiguration>;
+export declare interface DerivedDeclaration {
+    readonly sourceFileName: string;
+    readonly namespace?: Nullable<ModuleDeclaration>;
+    readonly fileName: string;
+    readonly body: string;
+}
+export declare function generateDerivedDeclarations(declarations: Array<DerivedDeclaration>, context: Context): Array<DerivedFile>;
+export declare class DeepMap<K, V> {
+    constructor();
+    clear(): void;
+    delete(key: Array<K>): void;
+    get(key: Array<K>): Nullable<V>;
+    has(key: Array<K>): boolean;
+    set(key: Array<K>, value: V): void;
+    entries(): Array<Tuple2<Array<K>, V>>;
+    keys(): Array<Array<K>>;
+    values(): Array<V>;
+}
+export declare namespace DeepMap {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <K, V>() => DeepMap<K, V>;
+    }
+}
+export declare function capitalize(string: string): string;
+export declare function camelize(string: string): string;
+export declare function isValidIdentifier(string: string): boolean;
+export declare function escapeIdentifier(string: string): string;
+/** @deprecated Prefer escapeIdentifier */
+export declare function identifier(string: string): string;
+/** @deprecated Prefer escapeIdentifier */
+export declare function constIdentifier(string: string): string;
+export declare function traverse(rootNode: Node, handler: (p0: Node) => void): void;