@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-6

package/build/lib/src/idlize.d.ts

@@ -1,25 +0,0 @@
-import * as ts from "typescript";
-import * as idl from "./idl";
-import { GenerateOptions } from "./options";
-export declare function scanDirectory(dir: string, fileFilter: (file: string) => boolean, recursive?: boolean): string[];
-export declare function scanInputDirs(inputDirs: string[]): string[];
-export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
-export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
-export interface GenerateVisitor<T> {
-    visitPhase1(): T;
-    visitPhase2?(siblings: {
-        [key in string]: {
-            tsSourceFile: ts.SourceFile;
-            visitor: GenerateVisitor<T>;
-            result: T;
-            isAux: boolean;
-        };
-    }): T;
-}
-export declare function generate<T>(baseDirs: string[], lookupDirs: string[], inputFiles: string[], auxInputFiles: string[], outputDir: string, stdlibFile: string, visitorFactory: (sourceFile: ts.SourceFile, program: ts.Program, compilerHost: ts.CompilerHost) => GenerateVisitor<T>, options: GenerateOptions<T>): void;
-export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
-export declare function isInIdlize(entry: idl.IDLEntry | idl.IDLFile): boolean;
-export declare function isInIdlizeInterop(entry: idl.IDLEntry | idl.IDLFile): boolean;
-export declare function isInIdlizeInternal(entry: idl.IDLEntry | idl.IDLFile): boolean;
-export declare function isInIdlizeStdlib(entry: idl.IDLEntry | idl.IDLFile): boolean;
-//# sourceMappingURL=idlize.d.ts.map

package/build/lib/src/idlize.js

@@ -1,198 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as ts from "typescript";
-import * as fs from "fs";
-import * as path from "path";
-import * as idl from "./idl";
-import { isDefined } from "./util";
-export function scanDirectory(dir, fileFilter, recursive = false) {
-    const dirsToVisit = [path.resolve(dir)];
-    const result = [];
-    while (dirsToVisit.length > 0) {
-        let dir = dirsToVisit.pop();
-        let dirents = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of dirents) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isFile()) {
-                if (fileFilter(fullPath)) {
-                    result.push(fullPath);
-                }
-            }
-            else if (recursive && entry.isDirectory()) {
-                dirsToVisit.push(fullPath);
-            }
-        }
-    }
-    return result;
-}
-export function scanInputDirs(inputDirs, fileFilter = undefined, recursive = false) {
-    if (typeof fileFilter === 'undefined')
-        return scanInputDirs(inputDirs, (_) => true, recursive);
-    if (typeof fileFilter === 'string')
-        return scanInputDirs(inputDirs, (file) => file.endsWith(fileFilter), recursive);
-    const resolvedInputDirs = inputDirs.map(dir => path.resolve(dir));
-    console.log("Resolved input directories:", resolvedInputDirs);
-    return resolvedInputDirs.flatMap(dir => {
-        if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
-            console.log(`Processing all definitions from directory: ${dir}`);
-            return scanDirectory(dir, fileFilter, recursive);
-        }
-        else {
-            console.warn(`Warning: Directory does not exist or is not a directory: ${dir}`);
-            return [];
-        }
-    }).sort((a, b) => {
-        return path.basename(a).localeCompare(path.basename(b));
-    });
-}
-function fileExists(fileName) {
-    return ts.sys.fileExists(fileName);
-}
-export function generate(baseDirs, lookupDirs, inputFiles, auxInputFiles, outputDir, stdlibFile, visitorFactory, options) {
-    var _a, _b, _c;
-    if (options.enableLog) {
-        console.log("Starting generation process...");
-    }
-    if (inputFiles.length === 0) {
-        console.error("Error: No input files specified.");
-        process.exit(1);
-    }
-    let input = new Set;
-    let auxInput = new Set;
-    {
-        const resolveOne = (file, tag) => {
-            const fullPath = path.resolve(file);
-            if (fs.existsSync(fullPath)) {
-                if (options.enableLog)
-                    console.log(`Including ${tag} file: ${fullPath}`);
-                return fullPath;
-            }
-            else
-                console.warn(`Warning: ${tag} file does not exist: ${fullPath}`);
-        };
-        inputFiles.map(file => resolveOne(file, "file")).filter(isDefined).sort().map(file => input.add(file));
-        auxInputFiles.map(file => resolveOne(file, "aux file")).filter(isDefined).sort().map(file => auxInput.add(file));
-    }
-    const compilerHostBase = ts.createCompilerHost(options.compilerOptions);
-    const compilerHost = Object.assign(Object.assign({}, compilerHostBase), { resolveModuleNames: (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
-            const resolvedModules = [];
-            for (let moduleName of moduleNames) {
-                // TODO: move this replacement table to some external config...
-                {
-                    const replacement = {
-                        "../component/navigation": "@internal/component/ets/navigation",
-                        "wrappedBuilderObject": "@internal/component/ets/common",
-                    };
-                    moduleName = replacement[moduleName] || moduleName;
-                }
-                let result = ts.resolveModuleName(moduleName, containingFile, options, compilerHostBase).resolvedModule;
-                if (result)
-                    resolvedModules.push(result);
-                else {
-                    // as a some fallback - try to resolve from parents of containingFile, lookupDirs
-                    for (let pov of [path.dirname(containingFile), ...lookupDirs]) {
-                        while (!result) {
-                            for (const extension of ["", ".d.ts", ".d.ets"]) {
-                                const candidate = `${moduleName}${extension}`;
-                                if (path.isAbsolute(candidate) && fileExists(candidate)) {
-                                    result = { resolvedFileName: candidate, extension: ts.Extension.Dts, isExternalLibraryImport: false };
-                                    break;
-                                }
-                                const povCandidate = path.join(pov, candidate);
-                                if (fileExists(povCandidate)) {
-                                    result = { resolvedFileName: povCandidate, extension: ts.Extension.Dts, isExternalLibraryImport: false };
-                                    break;
-                                }
-                            }
-                            if (result)
-                                break;
-                            result = ts.resolveModuleName(path.join(pov, moduleName), containingFile, options, compilerHostBase).resolvedModule;
-                            if (result)
-                                break;
-                            result = ts.resolveModuleName(moduleName, pov, options, compilerHostBase).resolvedModule;
-                            if (result)
-                                break;
-                            const nextPov = path.resolve(pov, "..");
-                            if (nextPov == pov)
-                                break;
-                            if (baseDirs.every(baseDir => path.relative(baseDir, nextPov).startsWith("..")))
-                                break;
-                            pov = nextPov;
-                        }
-                        if (result)
-                            break;
-                    }
-                    if (!result)
-                        console.warn(`Dts import at '${containingFile}', module '${moduleName}': unable to resolve source file path`);
-                    resolvedModules.push(result);
-                }
-            }
-            return resolvedModules;
-        } });
-    if (!fs.existsSync(stdlibFile))
-        throw new Error("Unable to find stdlib.d.ts");
-    const program = ts.createProgram([...input.values(), ...auxInput.values(), stdlibFile], options.compilerOptions, compilerHost);
-    if (options.enableLog) {
-        console.log("Initialized TypeScript program with input files:", input);
-    }
-    if (outputDir && !fs.existsSync(outputDir))
-        fs.mkdirSync(outputDir, { recursive: true });
-    const typeChecker = program.getTypeChecker();
-    (_a = options.onBegin) === null || _a === void 0 ? void 0 : _a.call(options, outputDir, typeChecker);
-    const dtsFileName2Visitor = {};
-    for (const sourceFile of program.getSourceFiles()) {
-        const resolvedSourceFileName = path.resolve(sourceFile.fileName);
-        const isAux = !input.has(resolvedSourceFileName);
-        if (options.enableLog) {
-            console.log(`Processing ${isAux ? "aux " : ""}file: ${resolvedSourceFileName}`);
-        }
-        // Walk the tree to search for classes
-        const visitor = visitorFactory(sourceFile, program, compilerHost);
-        const result = visitor.visitPhase1();
-        dtsFileName2Visitor[sourceFile.fileName] = {
-            tsSourceFile: sourceFile,
-            visitor,
-            result,
-            isAux: isAux
-        };
-    }
-    for (const resolvedSourceFileName in dtsFileName2Visitor) {
-        const visitorStaff = dtsFileName2Visitor[resolvedSourceFileName];
-        if (visitorStaff.visitor.visitPhase2)
-            visitorStaff.result = visitorStaff.visitor.visitPhase2(dtsFileName2Visitor);
-    }
-    for (const resolvedSourceFileName in dtsFileName2Visitor) {
-        const visitorStaff = dtsFileName2Visitor[resolvedSourceFileName];
-        (_b = options.onSingleFile) === null || _b === void 0 ? void 0 : _b.call(options, visitorStaff.result, outputDir, visitorStaff.tsSourceFile, visitorStaff.isAux);
-    }
-    (_c = options.onEnd) === null || _c === void 0 ? void 0 : _c.call(options, outputDir);
-    if (options.enableLog) {
-        console.log("Generation completed.");
-    }
-}
-export const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
-export function isInIdlize(entry) {
-    return idl.isInPackage(entry, "idlize");
-}
-export function isInIdlizeInterop(entry) {
-    return idl.isInPackage(entry, `${PACKAGE_IDLIZE_INTERNAL}.interop`);
-}
-export function isInIdlizeInternal(entry) {
-    return idl.isInPackage(entry, PACKAGE_IDLIZE_INTERNAL);
-}
-export function isInIdlizeStdlib(entry) {
-    return idl.isInPackage(entry, "idlize.stdlib");
-}
-//# sourceMappingURL=idlize.js.map

package/build/lib/src/options.d.ts

@@ -1,13 +0,0 @@
-import * as ts from "typescript";
-export interface GenerateOptions<T> {
-    compilerOptions: ts.CompilerOptions;
-    onBegin?: (outDir: string, typeChecker: ts.TypeChecker) => void;
-    onSingleFile?: (entries: T, outDir: string, inputFile: ts.SourceFile, isAux: boolean) => void;
-    onEnd?: (outDir: string) => void;
-    enableLog?: boolean;
-    recursive?: boolean;
-}
-export interface GenericVisitor<T> {
-    visitWholeFile(): T;
-}
-//# sourceMappingURL=options.d.ts.map

package/build/lib/src/peer-generation/BuilderClass.d.ts

@@ -1,20 +0,0 @@
-import { IDLInterface, IDLReferenceType } from "../idl";
-import { Field, Method } from "../LanguageWriters/LanguageWriter";
-export declare class BuilderClass {
-    readonly declaration: IDLInterface;
-    readonly name: string;
-    readonly generics: string[] | undefined;
-    readonly isInterface: boolean;
-    readonly superClass: IDLReferenceType | undefined;
-    readonly fields: Field[];
-    readonly constructors: Method[];
-    readonly methods: Method[];
-    readonly needBeGenerated: boolean;
-    constructor(declaration: IDLInterface, name: string, generics: string[] | undefined, isInterface: boolean, superClass: IDLReferenceType | undefined, fields: Field[], constructors: Method[], methods: Method[], needBeGenerated?: boolean);
-}
-/**
- * Builder classes are classes with methods which have only one parameter and return only itself
- */
-export declare function isBuilderClass(declaration: IDLInterface): boolean;
-export declare function methodsGroupOverloads(methods: Method[]): Method[][];
-//# sourceMappingURL=BuilderClass.d.ts.map

package/build/lib/src/peer-generation/BuilderClass.js

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { generatorConfiguration } from "../config";
-export class BuilderClass {
-    constructor(declaration, name, generics, isInterface, superClass, fields, constructors, methods, needBeGenerated = true) {
-        this.declaration = declaration;
-        this.name = name;
-        this.generics = generics;
-        this.isInterface = isInterface;
-        this.superClass = superClass;
-        this.fields = fields;
-        this.constructors = constructors;
-        this.methods = methods;
-        this.needBeGenerated = needBeGenerated;
-    }
-}
-/**
- * Builder classes are classes with methods which have only one parameter and return only itself
- */
-export function isBuilderClass(declaration) {
-    const className = declaration.name;
-    if (generatorConfiguration().builderClasses.includes(className)) {
-        return true;
-    }
-    // TBD: update builder class check condition.
-    // Only SubTabBarStyle, BottomTabBarStyle, DotIndicator, and DigitIndicator classes
-    // are used for now.
-    return false;
-    /*
-    if (peerGeneratorConfiguration().isStandardNameIgnored(className)) {
-        return false
-    }
-
-    const methods: (ts.MethodSignature | ts.MethodDeclaration)[] = [
-        ...ts.isClassDeclaration(declaration) ? declaration.members.filter(ts.isMethodDeclaration) : [],
-    ]
-
-    if (methods.length === 0) {
-        return false
-    }
-
-    return methods.every(it => it.type && className == it.type.getText() && it.parameters.length === 1)
-    */
-}
-export function methodsGroupOverloads(methods) {
-    const seenNames = new Set();
-    const groups = [];
-    for (const method of methods) {
-        if (seenNames.has(method.name))
-            continue;
-        seenNames.add(method.name);
-        groups.push(methods.filter(it => it.name === method.name));
-    }
-    return groups;
-}
-//# sourceMappingURL=BuilderClass.js.map