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

package/build/lib/src/config.js

@@ -12,8 +12,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as fs from "fs";
+import * as path from "path";
 import { D } from "./configDescriber";
-import { capitalize } from "./util";
+import { mergeJSONs } from "./configMerge";
 const T = {
     stringArray: () => D.array(D.string())
 };
@@ -24,34 +26,21 @@ export const ModuleConfigurationSchema = D.object({
     useFoldersLayout: D.maybe(D.boolean()),
     tsLikePackage: D.maybe(D.string()),
 });
-export const HookMethodSchema = D.object({
-    hookName: D.string(),
-    replaceImplementation: D.boolean()
-});
-export const TransformOnSerializeSchema = D.object({
-    from: D.string(),
-    to: D.string(),
-});
 export const CoreConfigurationSchema = D.object({
     ApiKind: D.number(),
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
     OptionalPrefix: D.string(),
-    transformOnSerialize: D.array(TransformOnSerializeSchema),
     rootComponents: T.stringArray(),
     standaloneComponents: T.stringArray(),
     parameterized: T.stringArray(),
     ignoreMaterialized: T.stringArray(),
-    ignoreGenerics: T.stringArray(),
     builderClasses: T.stringArray(),
     forceMaterialized: T.stringArray(),
     forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
     forceResource: T.stringArray(),
-    forceContext: T.stringArray(),
-    hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
-    libraryNameMapping: D.maybe(D.map(D.string(), D.map(D.string(), D.string())).onMerge('replace')),
     globalPackages: T.stringArray()
 });
 export const defaultCoreConfiguration = {
@@ -59,21 +48,16 @@ export const defaultCoreConfiguration = {
     TypePrefix: "",
     LibraryPrefix: "",
     OptionalPrefix: "",
-    transformOnSerialize: [],
     rootComponents: [],
     standaloneComponents: [],
     parameterized: [],
     ignoreMaterialized: [],
-    ignoreGenerics: [],
     builderClasses: [],
     forceMaterialized: [],
     forceCallback: new Map(),
     forceResource: [],
-    forceContext: [],
-    hooks: new Map(),
     moduleName: "",
     modules: new Map(),
-    libraryNameMapping: new Map(),
     globalPackages: []
 };
 let currentConfig = defaultCoreConfiguration;
@@ -90,18 +74,18 @@ export function generatorTypePrefix() {
     const conf = generatorConfiguration();
     return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
-export function getHookMethod(className, methodName) {
-    var _a, _b;
-    const hookMethods = generatorConfiguration().hooks.get(className);
-    if (!hookMethods)
-        return undefined;
-    const hook = hookMethods.get(methodName);
-    if (!hook)
-        return undefined;
-    const method = {
-        hookName: (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`,
-        replaceImplementation: (_b = hook.replaceImplementation) !== null && _b !== void 0 ? _b : true
-    };
-    return method;
+function parseConfigFile(configurationFile) {
+    if (!fs.existsSync(configurationFile))
+        throw new Error(`Configuration file ${configurationFile} does not exist!`);
+    const data = fs.readFileSync(path.resolve(configurationFile)).toString();
+    return JSON.parse(data);
+}
+export function parseConfigFiles(schema, configurationFiles) {
+    const json = mergeJSONs(configurationFiles.map(parseConfigFile), schema);
+    const result = schema.validate(json);
+    if (!result.success()) {
+        throw new Error("Configuration is not valid!\n" + result.error() + '\n');
+    }
+    return result.unwrap();
 }
 //# sourceMappingURL=config.js.map

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

@@ -0,0 +1,3 @@
+import { ConfigSchema } from "./configDescriber";
+export declare function mergeJSONs(objects: unknown[], schema: ConfigSchema<any>): unknown;
+//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2025 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 { inspectSchema } from "./configDescriber";
+function mergeJSON(a, b, path, schema) {
+    if (a === undefined && b !== undefined) {
+        return b;
+    }
+    if (b === undefined && a !== undefined) {
+        return a;
+    }
+    const inspector = inspectSchema(schema);
+    const info = inspector.inspectPath(path.join('.'));
+    if (!info || info.mergeStrategy !== 'replace') {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.concat(b);
+        }
+        if (typeof a === 'object' && typeof b === 'object') {
+            if (a !== null && b !== null) {
+                const aObj = a;
+                const bObj = b;
+                const result = {};
+                for (const key in a) {
+                    if (key in b) {
+                        result[key] = mergeJSON(aObj[key], bObj[key], path.concat([key]), schema);
+                    }
+                    else {
+                        result[key] = aObj[key];
+                    }
+                }
+                for (const key in b) {
+                    if (key in a) {
+                        result[key] = mergeJSON(aObj[key], bObj[key], path.concat([key]), schema);
+                    }
+                    else {
+                        result[key] = bObj[key];
+                    }
+                }
+                return result;
+            }
+        }
+    }
+    return b;
+}
+export function mergeJSONs(objects, schema) {
+    let result = undefined;
+    for (const obj of objects) {
+        result = mergeJSON(result, obj, [], schema);
+    }
+    return result;
+}
+//# sourceMappingURL=configMerge.js.map

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

@@ -6,7 +6,7 @@ export type MessageSeverity = "fatal" | "error" | "warning" | "information" | "h
 /**
  * Diagnostic message severity values.
  */
-export declare let MessageSeverityList: MessageSeverity[];
+export declare const MessageSeverityList: MessageSeverity[];
 /**
  * Message that reports specific error/warning, contains multiple parts and fixes.
  * LSP note:
@@ -84,7 +84,6 @@ export interface Range {
      */
     end: Position;
 }
-export declare function commonRange(range1: Range, range2: Range): Range;
 /**
  * Position in a document.
  * LSP note: In LSP positions are zero-based (that needs conversion) and UTF-16 by default.
@@ -99,9 +98,6 @@ export interface Position {
      */
     character: number;
 }
-export declare function comparePositions(a: Position, b: Position): number;
-export declare function minPosition(a: Position, b: Position): Position;
-export declare function maxPosition(a: Position, b: Position): Position;
 /**
  * Diff component of diagnostic message related to specific file/location.
  */

package/build/lib/src/diagnostictypes.js

@@ -15,33 +15,7 @@
 /**
  * Diagnostic message severity values.
  */
-export let MessageSeverityList = ["fatal", "error", "warning", "information", "hint"];
-export function commonRange(range1, range2) {
-    let start = minPosition(range1.start, range2.start);
-    let end = maxPosition(range1.end, range2.end);
-    return { start, end };
-}
-export function comparePositions(a, b) {
-    if (a.line < b.line) {
-        return -1;
-    }
-    if (a.line > b.line) {
-        return 1;
-    }
-    if (a.character < b.character) {
-        return -1;
-    }
-    if (a.character > b.character) {
-        return 1;
-    }
-    return 0;
-}
-export function minPosition(a, b) {
-    return comparePositions(a, b) == -1 ? a : b;
-}
-export function maxPosition(a, b) {
-    return comparePositions(a, b) == 1 ? a : b;
-}
+export const MessageSeverityList = ["fatal", "error", "warning", "information", "hint"];
 /**
  * Collection of diagnostic messages with calculated statistics.
  */

package/build/lib/src/from-idl/DtsPrinter.js

@@ -13,11 +13,11 @@
  * limitations under the License.
  */
 import { indentedBy, isInNamespace } from "../util";
-import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, isUnspecifiedGenericType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType } from "../idl";
+import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, isCallback, isConstructor, isContainerType, isEnum, isInterface, isMethod, isPrimitiveType, isProperty, isReferenceType, isSyntheticEntry, isTypeParameterType, isTypedef, isUnionType, isImport, isVersion, isNamespace, IDLExtendedAttributes, IDLAccessorAttribute, IDLVoidType, IDLStringType, IDLUndefinedType, isCallable, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, linearizeNamespaceMembers, isNamedNode, IDLThisType, isOptionalType, IDLI8Type, IDLU8Type, IDLI16Type, IDLU16Type, IDLI32Type, IDLU32Type, IDLI64Type, IDLU64Type, IDLF16Type, IDLF32Type, IDLF64Type, IDLBufferType, IDLUnknownType, IDLBooleanType, IDLNumberType, IDLPointerType, IDLInterfaceSubkind, escapeIDLKeyword, getNamespacesPathFor, IDLBigintType, IDLDate, IDLFunctionType, getQualifiedName, IDLObjectType, isConstant, } from "../idl";
 import { resolveSyntheticType, parseIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
-import { isInIdlize } from "../idlize";
+import { isInIdlize } from "../idl";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;
@@ -61,6 +61,9 @@ export class CustomPrintVisitor {
         else if (isNamespace(node)) {
             this.printNamespace(node);
         }
+        else if (isConstant(node)) {
+            this.printConstant(node);
+        }
         else {
             throw new Error(`Unexpected node kind: ${IDLKind[node.kind]}`);
         }
@@ -306,8 +309,6 @@ export class CustomPrintVisitor {
                 return `${type.elementType.map(it => this.printTypeForTS(it)).join(",")}[]`;
             return `${mapContainerType(type)}<${type.elementType.map(it => this.printTypeForTS(it)).join(",")}>`;
         }
-        if (isUnspecifiedGenericType(type))
-            return `${type.name}<${type.typeArguments.map(it => this.printTypeForTS(it)).join(",")}>`;
         if (isReferenceType(type))
             return this.toTypeName(type);
         if (isUnionType(type))
@@ -331,8 +332,14 @@ export class CustomPrintVisitor {
                     }
                 }
                 let typeSpec = getQualifiedName(decl, "namespace.name");
-                if (node.typeArguments)
-                    typeSpec = `${typeSpec}<${node.typeArguments.map(it => this.printTypeForTS(it))}>`;
+                if (node.typeArguments) {
+                    let typeArguments = node.typeArguments;
+                    if (node.name.endsWith(".Callback")) {
+                        console.log("Removing second type arguments for Callback type. Reason: in .d.ts declarations will be only callback with one type argument from ohos.base");
+                        typeArguments = [typeArguments[0]];
+                    }
+                    typeSpec = `${typeSpec}<${typeArguments.map(it => this.printTypeForTS(it))}>`;
+                }
                 return typeSpec;
             }
         }

package/build/lib/src/from-idl/IDLLinter.d.ts

@@ -1,6 +1,5 @@
 import * as idl from "../idl";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
-import { IDLTokenInfoMap } from "./deserialize";
 export declare enum IDLValidationDiagnosticsCode {
     INVALID_EXTENDED_ATTRIBUTE = 1000,
     ENUM_IS_NOT_CONSISTENT = 1001,
@@ -15,6 +14,7 @@ export interface IDLLinterOptions {
     checkEnumsConsistency: boolean;
     checkReferencesResolved: boolean;
 }
+export declare const DefaultIDLLinterOptions: IDLLinterOptions;
 interface IDLLinterContextRecord {
     typeParameters: Set<string>;
 }
@@ -30,10 +30,9 @@ export declare class IDLLinter {
     protected file: idl.IDLFile;
     protected resolver: ReferenceResolver;
     protected options: IDLLinterOptions;
-    protected info?: IDLTokenInfoMap | undefined;
     protected context: IDLLinterContext;
     diagnostics: IDLLinterDiagnosticsSummary[];
-    constructor(file: idl.IDLFile, resolver: ReferenceResolver, options: IDLLinterOptions, info?: IDLTokenInfoMap | undefined);
+    constructor(file: idl.IDLFile, resolver: ReferenceResolver, options: IDLLinterOptions);
     visit(): IDLLinterDiagnosticsSummary[];
     protected enter(node: idl.IDLNode): (() => void) | undefined;
     protected check(node: idl.IDLNode): void;
@@ -51,6 +50,6 @@ export declare class IDLLinterError extends Error {
     size: number;
     constructor(message: string, size: number);
 }
-export declare function verifyIDLLinter(file: idl.IDLFile, resolver: ReferenceResolver, options: IDLLinterOptions, info?: IDLTokenInfoMap): true;
+export declare function verifyIDLLinter(file: idl.IDLFile, resolver: ReferenceResolver, options: IDLLinterOptions): true;
 export {};
 //# sourceMappingURL=IDLLinter.d.ts.map

package/build/lib/src/from-idl/IDLLinter.js

@@ -14,6 +14,24 @@ const ENG_ErrorDescription = {
 export const IDLValidationErrorDescription = {
     en_EN: ENG_ErrorDescription
 };
+export const DefaultIDLLinterOptions = {
+    validEntryAttributes: new Map([
+        [idl.IDLKind.Import, ["Deprecated", "Documentation"]],
+        [idl.IDLKind.Namespace, ["DefaultExport", "Deprecated", "Documentation", "VerbatimDts"]],
+        [idl.IDLKind.Const, ["DefaultExport", "Deprecated", "Documentation"]],
+        [idl.IDLKind.Property, ["DefaultExport", "Optional", "Accessor", "Deprecated", "CommonMethod", "Protected", "DtsName", "Documentation"]],
+        [idl.IDLKind.Interface, ["DefaultExport", "Predefined", "TSType", "CPPType", "Entity", "Interfaces", "ParentTypeArguments", "Component", "Synthetic", "Deprecated", "HandWrittenImplementation", "Documentation", "TypeParameters", "ComponentInterface"]],
+        [idl.IDLKind.Callback, ["DefaultExport", "Deprecated", "Async", "Synthetic", "Documentation", "TypeParameters"]],
+        [idl.IDLKind.Method, ["DefaultExport", "Optional", "DtsTag", "DtsName", "Throws", "Deprecated", "IndexSignature", "Protected", "Documentation", "CallSignature", "TypeParameters"]],
+        [idl.IDLKind.Callable, ["DefaultExport", "CallSignature", "Deprecated", "Documentation", "CallSignature"]],
+        [idl.IDLKind.Typedef, ["DefaultExport", "Deprecated", "Import", "Documentation", "TypeParameters"]],
+        [idl.IDLKind.Enum, ["DefaultExport", "Deprecated", "Documentation"]],
+        [idl.IDLKind.EnumMember, ["OriginalEnumMemberName", "Deprecated", "Documentation"]],
+        [idl.IDLKind.Constructor, ["Deprecated", "Documentation"]]
+    ]),
+    checkEnumsConsistency: true,
+    checkReferencesResolved: false,
+};
 class IDLLinterContext {
     constructor() {
         this.stack = [{ typeParameters: new Set() }];
@@ -48,11 +66,10 @@ function parseTypeParameter(param) {
     return param;
 }
 export class IDLLinter {
-    constructor(file, resolver, options, info) {
+    constructor(file, resolver, options) {
         this.file = file;
         this.resolver = resolver;
         this.options = options;
-        this.info = info;
         this.context = new IDLLinterContext();
         this.diagnostics = [];
     }
@@ -85,25 +102,23 @@ export class IDLLinter {
         }
     }
     checkValidAttributes(entry, validAttributes) {
-        var _a, _b, _c;
+        var _a;
         if (!entry.extendedAttributes)
             return;
         for (const attr of entry.extendedAttributes) {
             if (!validAttributes.includes(attr.name)) {
-                const tokens = (_a = this.info) === null || _a === void 0 ? void 0 : _a.get(attr);
-                const ident = tokens === null || tokens === void 0 ? void 0 : tokens.name;
                 const file = idl.getFileFor(entry);
                 this.diagnostics.push({
                     code: IDLValidationDiagnosticsCode.INVALID_EXTENDED_ATTRIBUTE,
-                    file: (_b = file === null || file === void 0 ? void 0 : file.fileName) !== null && _b !== void 0 ? _b : '',
+                    file: (_a = file === null || file === void 0 ? void 0 : file.fileName) !== null && _a !== void 0 ? _a : '',
                     message: `Invalid attribute '${attr.name}'`,
-                    position: [(_c = ident === null || ident === void 0 ? void 0 : ident.position) !== null && _c !== void 0 ? _c : 0, attr.name.length]
+                    position: [0, attr.name.length]
                 });
             }
         }
     }
     checkEnumConsistency(entry) {
-        var _a, _b, _c, _d;
+        var _a;
         const fileName = (_a = idl.getFileFor(entry)) === null || _a === void 0 ? void 0 : _a.fileName;
         let hasNumber = false;
         let hasString = false;
@@ -114,21 +129,16 @@ export class IDLLinter {
                 hasNumber = true;
         }
         if (hasNumber && hasString) {
-            const tokens = (_b = this.info) === null || _b === void 0 ? void 0 : _b.get(entry);
-            const ident = tokens === null || tokens === void 0 ? void 0 : tokens.name;
             this.diagnostics.push({
                 code: IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT,
                 file: fileName !== null && fileName !== void 0 ? fileName : '',
                 message: "Enum includes both string and number values",
-                position: [
-                    (_c = ident === null || ident === void 0 ? void 0 : ident.position) !== null && _c !== void 0 ? _c : 0,
-                    (_d = ident === null || ident === void 0 ? void 0 : ident.value.length) !== null && _d !== void 0 ? _d : 0
-                ]
+                position: [0, 0]
             });
         }
     }
     checkReferenceResolved(reference) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a;
         if (this.context.hasTypeParameter(reference.name)) {
             return;
         }
@@ -137,19 +147,11 @@ export class IDLLinter {
             const parentFile = idl.getFileFor(reference);
             const parentNamespace = idl.fetchNamespaceFrom(reference);
             const scopeName = parentNamespace ? idl.getFQName(parentNamespace) : idl.getPackageName(parentFile);
-            let current = reference;
-            let tokens = (_a = this.info) === null || _a === void 0 ? void 0 : _a.get(current);
-            let location = tokens === null || tokens === void 0 ? void 0 : tokens.base;
-            while (current !== undefined && tokens === undefined) {
-                current = current.parent;
-                tokens = (_b = this.info) === null || _b === void 0 ? void 0 : _b.get(current);
-                location = tokens === null || tokens === void 0 ? void 0 : tokens.name;
-            }
             this.diagnostics.push({
                 code: IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED,
-                file: (_c = parentFile.fileName) !== null && _c !== void 0 ? _c : '',
+                file: (_a = parentFile.fileName) !== null && _a !== void 0 ? _a : '',
                 message: `Can not resolve reference '${reference.name}' defined in scope '${scopeName}'`,
-                position: [(_d = location === null || location === void 0 ? void 0 : location.position) !== null && _d !== void 0 ? _d : 0, (_f = (_e = location === null || location === void 0 ? void 0 : location.value) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0]
+                position: [0, 0]
             });
         }
     }
@@ -246,14 +248,10 @@ function prettyPrintErrors(errors, text) {
         return errorText;
     }).join(EOL);
 }
-export function verifyIDLLinter(file, resolver, options, info) {
-    var _a, _b;
-    const result = new IDLLinter(file, resolver, options, info).visit();
+export function verifyIDLLinter(file, resolver, options) {
+    const result = new IDLLinter(file, resolver, options).visit();
     if (result.length) {
-        const isTTY = Boolean(process.stdout.isTTY);
-        const errorMessage = info
-            ? isTTY ? prettyPrintErrors(result, (_a = file.text) !== null && _a !== void 0 ? _a : '') : printErrors(result, (_b = file.text) !== null && _b !== void 0 ? _b : '')
-            : printErrorWithoutLocation(result);
+        const errorMessage = printErrorWithoutLocation(result);
         throw new IDLLinterError(errorMessage, result.length);
     }
     return true;

package/build/lib/src/from-idl/deserialize.d.ts

@@ -1,11 +1,10 @@
-import * as webidl2 from "webidl2";
 import * as idl from "../idl";
-export type WebIDLTokenCollection = Record<string, webidl2.Token | null | undefined>;
-export type IDLTokenInfoMap = Map<unknown, WebIDLTokenCollection>;
 export declare function addSyntheticType(name: string, type: idl.IDLEntry): void;
 export declare function resolveSyntheticType(type: idl.IDLReferenceType): idl.IDLEntry | undefined;
 export declare function toIdlType(fileName: string, content: string): idl.IDLType;
+export declare function toIdlTypeList(fileName: string, content: string): idl.IDLType[];
+export declare function compareNodes(a: idl.IDLNode, b: idl.IDLNode): boolean;
 export declare function compareParsingResults(oldFile: idl.IDLFile, newFile: idl.IDLFile): boolean;
 export declare function parseIDLFile(fileName: string, content?: string, quiet?: boolean): idl.IDLFile;
-export declare function parseIDLFileNew(fileName: string, content?: string, registerSynthetics?: boolean): idl.IDLFile;
+export declare function parseIDLFileNew(fileName: string, content?: string): idl.IDLFile;
 //# sourceMappingURL=deserialize.d.ts.map