devextreme-internal-tools 12.0.0-beta.1 → 12.0.0-beta.3

package/ts/common/ts-type-resolving.d.ts

@@ -0,0 +1,16 @@
+import { Symbol, TypeChecker, Type, Node, Declaration, TypeReferenceNode } from 'typescript';
+import { Typing, TypeDeclaration, PropDeclaration } from '../discoverer/data-model';
+export declare function createTypeProcessor(checker: TypeChecker, baseDir: string): (member: Symbol, tsTypes: Record<string, TypeDeclaration>) => void;
+export declare function isExternalDeclaration(declaration: Node): boolean;
+interface TypeDescriptor {
+    declaration: Declaration;
+    propSymbols: Symbol[];
+}
+export declare function buildTypeDescriptor(type: Type): TypeDescriptor;
+export declare function isPublicType(symbol: Symbol): boolean;
+export declare function getPropDeclaration(checker: TypeChecker, prop: Symbol, baseDir: string, currentDeclaration?: Declaration): PropDeclaration;
+export declare function isMember(node: Node, checker: TypeChecker): boolean;
+export declare function isDocumentedTypeReference(node: TypeReferenceNode, checker: TypeChecker): boolean;
+export declare function findParamTypeSymbol(node: Node, checker: TypeChecker): Symbol | undefined;
+export declare function resolveType(node: Node, checker: TypeChecker, baseDir: string): Typing | undefined;
+export {};

package/ts/common/ts-utils.d.ts

@@ -0,0 +1,31 @@
+import { ClassDeclaration, CompilerOptions, GetAccessorDeclaration, NamedDeclaration, Node, LiteralTypeNode, ObjectType, ParameterDeclaration, Program, PropertyDeclaration, PropertySignature, SourceFile, SubstitutionType, Symbol, SymbolFlags, SyntaxKind, Type, TypeAliasDeclaration, TypeChecker, TypeParameterDeclaration, TypeReference, UnionOrIntersectionType, UnionOrIntersectionTypeNode, VariableDeclaration, Declaration, InterfaceDeclaration, TypeReferenceNode, Statement, ExportAssignment } from 'typescript';
+export declare function isStructuredType(type: Type): boolean;
+export declare function isUnionOrIntersectionType(type: Type): type is UnionOrIntersectionType;
+export declare function isUnionOrIntersectionTypeNode(node: Node): node is UnionOrIntersectionTypeNode;
+export declare function isTypeReference(type: Type): type is TypeReference;
+export declare function isObjectType(type: Type): type is ObjectType;
+export declare function isSubstitutionType(type: Type): type is SubstitutionType;
+export declare function isEnumTypeNode(node: Node): boolean;
+declare type NodeWithType = GetAccessorDeclaration | ParameterDeclaration | PropertyDeclaration | PropertySignature | TypeAliasDeclaration | VariableDeclaration;
+export declare function isNodeWithType(node: Node): node is NodeWithType;
+export declare function isNamedDeclaration(node: Node): node is NamedDeclaration;
+export declare function isOptional(symbol: Symbol): boolean;
+export declare function getTypeSymbols(type: Type): Symbol[];
+export declare function getTypeSymbol(type: Type): Symbol;
+export declare function getNestedSymbols(type: Type): Symbol[];
+export declare function getValueType(kind: SyntaxKind): string | undefined;
+export declare function getAliasSymbol(symbol: Symbol | undefined, checker: TypeChecker): Symbol | undefined;
+export declare function getSymbolDecalartions(symbol: Symbol | undefined, checker: TypeChecker): Node[];
+export declare function isDefaultExportStatement(statement: Statement): statement is ExportAssignment;
+export declare function createProgram(rootNames: string[], compilerOptions?: CompilerOptions): Program;
+export declare function createProgram(sourceFiles: SourceFile[], compilerOptions?: CompilerOptions): Program;
+export declare function getModule(node: Node, baseDir: string): string | undefined;
+export declare function getGenericParameterDeclaration(typeNode: Node, checker: TypeChecker): TypeParameterDeclaration | undefined;
+export declare function getReferencedNodes(node: Node, checker: TypeChecker): Node[];
+export declare function getNumberLiteralValue(node: LiteralTypeNode): number | undefined;
+export declare function isOptionalMember(declaration: Declaration): boolean;
+export declare function isReadonlyMember(declaration: Declaration): boolean;
+export declare function isTypeLikeDeclaration(node: Node): node is TypeAliasDeclaration | InterfaceDeclaration | ClassDeclaration | TypeReferenceNode;
+export declare function isTypeDeclaration(node: Node): node is TypeAliasDeclaration | InterfaceDeclaration | ClassDeclaration;
+export declare function hasFlag(symbol: Symbol, flag: SymbolFlags): boolean;
+export {};

package/ts/common/type-resolving.d.ts

@@ -0,0 +1,42 @@
+import { Node, TypeChecker, Symbol } from 'typescript';
+import { FunctionTypeParamField } from './tags/parameter-field-tag';
+export interface MemberType {
+    id: string;
+    typeArguments?: MemberType[];
+}
+export interface FunctionTypeParam {
+    id: string;
+    fields?: FunctionTypeParamField[];
+}
+export interface FunctionMemberType extends MemberType {
+    functionParams?: FunctionTypeParam[];
+    functionReturnType?: string;
+    isCallback?: boolean;
+}
+export interface StringLiteralMemberType extends MemberType {
+    id: 'string';
+    value: string;
+}
+export interface NumberLiteralMemberType extends MemberType {
+    id: 'number';
+    value: number;
+}
+interface BooleanLiteralMemberType extends MemberType {
+    id: 'false' | 'true';
+}
+interface NullLiteralMemberType extends MemberType {
+    id: 'null';
+}
+export declare type LiteralMemberType = StringLiteralMemberType | NumberLiteralMemberType | BooleanLiteralMemberType | NullLiteralMemberType;
+export declare function isStringLiteralMemberType(type: LiteralMemberType): type is StringLiteralMemberType;
+export declare function isNumberLiteralMemberType(type: LiteralMemberType): type is NumberLiteralMemberType;
+export interface GenericArgumentType extends MemberType {
+    isGenericArgument: boolean;
+}
+export declare function isFunctionMemberType(memberType: MemberType): memberType is FunctionMemberType;
+export declare function isLiteralMemberType(memberType: MemberType): memberType is StringLiteralMemberType | NumberLiteralMemberType;
+export declare function isGenericArgumentType(memberType: MemberType): memberType is GenericArgumentType;
+export declare function resolveLiteralType(typeNode: Node): LiteralMemberType | undefined;
+export declare function getFullTypeName(symbol: Symbol, typeName: string, checker: TypeChecker, baseDir: string, typeArguments: MemberType[]): string;
+export declare function resolveNodeType(node: Node, checker: TypeChecker, baseDir: string): MemberType | undefined;
+export {};

package/ts/common/utils.d.ts

@@ -0,0 +1,22 @@
+export declare function walkDirSync(rootDir: string, callback: (f: string) => void): void;
+export declare function enumerateFiles(targetDir: string, fileExtensionExpression?: string, exclude?: RegExp): string[];
+export declare function mergeArrays<T>(arr: T[][]): T[];
+export declare function toArray<T>(iterator: Iterator<T> | undefined): T[] | undefined;
+export declare function distinct<T1, T2>(arr: T1[], getKey?: ((item: T1) => T2)): T1[];
+export declare function getInnerPath(fullPath: string, baseDir: string): string | undefined;
+export declare function buildQualifiedName(...parts: string[]): string;
+export declare function toSortedRecord<R extends Record<string, unknown>>(obj: R): R;
+export declare function toInvariantPath(path: string): string;
+export declare function isEscapedUncPath(path: string): boolean;
+export declare function revertEscaping(arg: string): string;
+export declare function removeKnownExtensions(path: string): string;
+export declare function undefinedOrNonEmpty<T extends unknown[]>(values: T): T;
+export declare function split<TValue, TGroup extends PropertyKey>(values: TValue[], spliter: (value: TValue) => TGroup): Record<TGroup, TValue[]>;
+declare type Predicate<T> = (arg: T) => boolean;
+export declare function not<T>(f: Predicate<T>): Predicate<T>;
+export declare function everyOf<T, TNarrowed extends T>(values: T[], guard: (value: T) => value is TNarrowed): values is TNarrowed[];
+declare type Guard<T, TNarrowed extends T> = (value: T) => value is TNarrowed;
+export declare function combineGuards<T, T1 extends T, T2 extends T>(guard1: Guard<T, T1>, guard2: Guard<T, T2>): Guard<T, T1 | T2>;
+export declare function combineGuards<T, T1 extends T, T2 extends T, T3 extends T>(guard1: Guard<T, T1>, guard2: Guard<T, T2>, guard3: Guard<T, T3>): Guard<T, T1 | T2 | T3>;
+export declare function combineGuards<T, T1 extends T, T2 extends T, T3 extends T, T4 extends T>(guard1: Guard<T, T1>, guard2: Guard<T, T2>, guard3: Guard<T, T3>, guard4: Guard<T, T4>): Guard<T, T1 | T2 | T3 | T4>;
+export {};

package/ts/component-exports-generator/generator.d.ts

@@ -0,0 +1,3 @@
+import { CompilerOptions, Program } from 'typescript';
+export declare function generateComponentReexports(targetFiles: string[], compilerOptions?: CompilerOptions): void;
+export declare function createReexportsGenerator(program: Program): (filePath: string) => string;

package/ts/discoverer/data-model.d.ts

@@ -0,0 +1,105 @@
+export declare type EnumLikeType = {
+    kind: 'enum';
+    id: string;
+    valueType: 'string';
+    values: string[];
+} | {
+    kind: 'enum';
+    id: string;
+    valueType: 'number';
+    values: number[];
+};
+export interface Root {
+    members: Member[];
+    types: Record<string, TypeDeclaration | EnumLikeType>;
+}
+export declare type Member = {
+    id: string;
+    tags: MemberTags;
+    optional?: boolean;
+    type?: TypeRef;
+    optionsType?: string;
+    typeParameters?: Record<string, GenericParamDeclaration>;
+    location?: {
+        file: string;
+    };
+};
+export interface MemberTags {
+    deprecated?: string[];
+    docid?: string[];
+    [key: string]: string[];
+}
+export interface TypeRef {
+    name: string;
+    file?: string;
+}
+export declare type Typing = ValueTyping | ReferenceTyping | GenericTyping | Union | Intersection | FunctionTyping | LiteralTyping;
+export interface TypingBase {
+    array?: boolean;
+    kind: typeof TypingKind[keyof typeof TypingKind];
+}
+export declare const TypingKind: {
+    readonly Value: 0;
+    readonly Reference: 1;
+    readonly Union: 2;
+    readonly Intersection: 3;
+    readonly Literal: 4;
+    readonly GenericArgument: 5;
+    readonly Function: 6;
+};
+export interface NamedTyping extends TypingBase {
+    id: string;
+    args?: Typing[];
+}
+export interface ValueTyping extends NamedTyping {
+    kind: typeof TypingKind.Value;
+}
+export interface ReferenceTyping extends NamedTyping {
+    kind: typeof TypingKind.Reference;
+    memberId?: string;
+}
+export interface GenericTyping extends NamedTyping {
+    kind: typeof TypingKind.GenericArgument;
+    memberId?: string;
+}
+interface CompositeTyping extends TypingBase {
+    types: Typing[];
+}
+export interface Union extends CompositeTyping {
+    kind: typeof TypingKind.Union;
+}
+export interface Intersection extends CompositeTyping {
+    kind: typeof TypingKind.Intersection;
+}
+export interface LiteralTyping extends TypingBase {
+    kind: typeof TypingKind.Literal;
+    value: string | number | null;
+}
+export interface FunctionTyping extends TypingBase {
+    kind: typeof TypingKind.Function;
+    params?: Record<string, FunctionParam>;
+    returnType: Typing;
+}
+interface FunctionParam {
+    type: Typing;
+    spread?: boolean;
+}
+export interface GenericParamDeclaration {
+    defaultValue?: Typing;
+}
+export interface TypeDeclaration {
+    kind: 'object';
+    typeParams?: Record<string, Typing>;
+    props: Record<string, PropDeclaration>;
+}
+export declare type PropDeclaration = {
+    type: Typing;
+} & (OwnProp | InheritedProp);
+interface OwnProp {
+    readonly?: boolean;
+    optional?: boolean;
+}
+interface InheritedProp {
+    inheritedFrom: string;
+}
+export {};

package/ts/discoverer/discovering-error.d.ts

@@ -0,0 +1,4 @@
+import { Node } from 'typescript';
+export declare class DiscoveringError extends Error {
+    constructor(message: string, nodes: Node[]);
+}

package/ts/discoverer/discovering.d.ts

@@ -0,0 +1,4 @@
+import { CompilerOptions } from './parsing';
+import { Root } from './data-model';
+export declare function discover(targetFiles: string[], targetDir: string, outputFile: string, toolsVersion?: string, compilerOptions?: CompilerOptions): void;
+export declare function discoverMembers(fileNames: string[], baseDir: string, compilerOptions?: CompilerOptions): Root;

package/ts/discoverer/parsing/enum-collecting.d.ts

@@ -0,0 +1,6 @@
+import { Symbol } from 'typescript';
+import { EnumLikeType } from '../data-model';
+export declare function createEnumsCollector(baseDir: string): {
+    addEnum(symbol: Symbol): void;
+    toRecord(): Record<string, EnumLikeType>;
+};

package/ts/discoverer/parsing/file-reader.d.ts

@@ -0,0 +1,2 @@
+import { SourceFile, Symbol, TypeChecker } from 'typescript';
+export declare function getDiscoverableSymbols(sourceFile: SourceFile, checker: TypeChecker): Symbol[];

package/ts/discoverer/parsing/widget-parsing.d.ts

@@ -0,0 +1,11 @@
+import { Node, TypeChecker } from 'typescript';
+import { DocTag } from '../../common/tags/types';
+export declare function parseWidgetExtras(node: Node, tags: DocTag[], checker: TypeChecker, baseDir: string): {
+    optionsType: string;
+    isWidget: true;
+    tags: DocTag[];
+} | {
+    isWidget: false;
+    optionsType?: undefined;
+    tags?: undefined;
+};

package/ts/discoverer/parsing.d.ts

@@ -0,0 +1,29 @@
+import { CompilerOptions } from 'typescript';
+import { TypeDeclaration, EnumLikeType, GenericParamDeclaration } from './data-model';
+import { GeneralType } from './types';
+import { DocTag } from '../common/tags/types';
+import { ID } from '../common/id';
+export { CompilerOptions } from 'typescript';
+export declare type Descriptor = OptionDescriptor | WidgetDescriptor;
+interface OptionDescriptor extends DescriptorBase {
+    kind: 'option';
+    optional: boolean;
+    type?: GeneralType;
+}
+export interface WidgetDescriptor extends DescriptorBase {
+    kind: 'widget';
+    optionsType: string;
+}
+interface DescriptorBase {
+    [ID]: string;
+    exported: boolean;
+    tags: DocTag[];
+    location?: {
+        file: string;
+    };
+    typeParameters?: Record<string, GenericParamDeclaration>;
+}
+export declare function parseFiles(files: string[], baseDir: string, compilerOptions: CompilerOptions | undefined): [
+    Descriptor[],
+    Record<string, TypeDeclaration | EnumLikeType>
+];

package/ts/discoverer/types.d.ts

@@ -0,0 +1,20 @@
+interface Standard {
+    name: 'string' | 'number' | 'any' | 'Array' | 'Record';
+}
+interface Custom {
+    name: string;
+    file: string;
+}
+interface Generic {
+    params: GeneralType[];
+}
+export declare type GeneralType = {
+    cat: 'standard';
+} & Standard | {
+    cat: 'standard-generic';
+} & Standard & Generic | {
+    cat: 'custom';
+} & Custom | {
+    cat: 'custom-generic';
+} & Custom & Generic;
+export {};

package/ts/logging.d.ts

@@ -0,0 +1,16 @@
+import { Node } from 'typescript';
+export declare type Level = keyof typeof levels;
+declare const levels: {
+    readonly trace: 5;
+    readonly debug: 4;
+    readonly info: 3;
+    readonly warn: 2;
+    readonly error: 1;
+    readonly fatal: 0;
+};
+declare const log: (msg: string, options?: {
+    lvl?: Level;
+    node?: Node;
+    e?: any;
+}) => void, logStart: () => any, setLogDir: (dir: string) => void, setAreaName: (areaName: string) => void;
+export { log, logStart, setLogDir, setAreaName, };

package/ts/modules-meta-generator/modules-meta-generator.d.ts

@@ -0,0 +1,3 @@
+import { CompilerOptions } from 'typescript';
+export declare function generateModulesMeta(targetFiles: string[], targetDir: string, output: string, compilerOptions: CompilerOptions | undefined, toolsVersion?: string): void;
+export declare function getModulesData(fileNames: string[], baseDir: string, compilerOptions?: CompilerOptions): Record<string, Record<string, unknown>>;

package/ts/react-components-generator/common-reexports-generator.d.ts

@@ -0,0 +1,2 @@
+declare function generate(module: string, reexports: string[]): string;
+export default generate;

package/ts/react-components-generator/common-reexports-generator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var template_1 = require("./template");
+var render = template_1.createTemplate("\nexport {<#~ it.reexports :reExport #>\n    <#= reExport #>,<#~#>\n} from \"devextreme/<#= it.module #>\";\n".trimStart());
+function generate(module, reexports) {
+    var result = render({ module: module, reexports: reexports });
+    return result;
+}
+exports.default = generate;
+//# sourceMappingURL=common-reexports-generator.js.map

package/ts/react-components-generator/common-reexports-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-reexports-generator.js","sourceRoot":"","sources":["../../../ts/react-components-generator/common-reexports-generator.ts"],"names":[],"mappings":";;AAAA,uCAA4C;AAE5C,IAAM,MAAM,GAA+D,yBAAc,CAAC,+GAIzF,CAAC,SAAS,EAAE,CAAC,CAAC;AAEf,SAAS,QAAQ,CAAC,MAAc,EAAE,SAAmB;IACnD,IAAM,MAAM,GAAG,MAAM,CAAC,EAAE,MAAM,QAAA,EAAE,SAAS,WAAA,EAAE,CAAC,CAAC;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,kBAAe,QAAQ,CAAC"}

package/ts/react-components-generator/component-generator.d.ts

@@ -0,0 +1,62 @@
+declare type IComponent = {
+    name: string;
+    baseComponentPath: string;
+    extensionComponentPath: string;
+    dxExportPath: string;
+    expectedChildren?: IExpectedChild[];
+    isExtension?: boolean;
+    subscribableOptions?: ISubscribableOption[];
+    independentEvents?: IIndependentEvents[];
+    templates?: string[];
+    propTypings?: IPropTyping[];
+    optionsTypeParams?: string[];
+} & {
+    nestedComponents?: INestedComponent[];
+    configComponentPath?: string;
+    containsReexports?: boolean;
+    narrowedEvents?: IOption[];
+};
+interface INestedComponent {
+    className: string;
+    optionName: string;
+    owners: string[];
+    options: IOption[];
+    templates?: string[];
+    expectedChildren?: IExpectedChild[];
+    predefinedProps?: Record<string, string>;
+    isCollectionItem?: boolean;
+}
+interface ISubscribableOption {
+    name: string;
+    type: string;
+    isSubscribable?: true;
+}
+interface IIndependentEvents {
+    name: string;
+}
+declare type IOption = {
+    name: string;
+    isSubscribable?: true;
+    isArray?: boolean;
+    type?: any;
+} & ({
+    type: string;
+    nested?: undefined;
+} | {
+    type?: undefined;
+    nested: IOption[];
+});
+interface IPropTyping {
+    propName: string;
+    types: string[];
+    acceptableType?: string;
+    acceptableValues?: string[];
+}
+interface IExpectedChild {
+    componentName: string;
+    optionName: string;
+    isCollectionItem?: boolean;
+}
+declare function generate(component: IComponent, generateReexports?: boolean, customTypeImports?: Record<string, Array<string>>, defaultTypeImports?: Record<string, string>, wildcardTypeImports?: Record<string, string>): string;
+export default generate;
+export { IComponent, IIndependentEvents, INestedComponent, IOption, ISubscribableOption, IPropTyping, };