npm - @idlizer/core - Versions diffs - 2.1.2 → 2.1.7 - Mend

@idlizer/core 2.1.2 → 2.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

package/build/lib/src/config.js CHANGED Viewed

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import { D } from "./configDescriber";
+import { capitalize } from "./util";
 const T = {
     stringArray: () => D.array(D.string())
 };
@@ -21,6 +22,9 @@ export const ModuleConfigurationSchema = D.object({
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
 });
+export const HookMethodSchema = D.object({
+    hookName: D.string(),
+});
 export const CoreConfigurationSchema = D.object({
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
@@ -31,10 +35,14 @@ export const CoreConfigurationSchema = D.object({
     ignoreMaterialized: T.stringArray(),
     builderClasses: T.stringArray(),
     forceMaterialized: T.stringArray(),
-    forceCallback: 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'),
+    externalModuleTypes: D.map(D.string(), D.string()).onMerge('replace'),
     moduleName: D.string(),
-    modules: D.map(D.string(), ModuleConfigurationSchema)
+    modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
+    globalPackages: T.stringArray()
 });
 export const defaultCoreConfiguration = {
     TypePrefix: "",
@@ -46,10 +54,14 @@ export const defaultCoreConfiguration = {
     ignoreMaterialized: [],
     builderClasses: [],
     forceMaterialized: [],
-    forceCallback: [],
+    forceCallback: new Map(),
+    forceResource: [],
     forceContext: [],
+    hooks: new Map(),
+    externalModuleTypes: new Map(),
     moduleName: "",
     modules: new Map(),
+    globalPackages: []
 };
 let currentConfig = defaultCoreConfiguration;
 export function setDefaultConfiguration(config) {
@@ -65,4 +77,14 @@ export function generatorTypePrefix() {
     const conf = generatorConfiguration();
     return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
+export function generatorHookName(className, methodName) {
+    var _a;
+    const hookMethods = generatorConfiguration().hooks.get(className);
+    if (!hookMethods)
+        return undefined;
+    const hook = hookMethods.get(methodName);
+    if (!hook)
+        return undefined;
+    return (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`;
+}
 //# sourceMappingURL=config.js.map

package/build/lib/src/configDescriber.d.ts CHANGED Viewed

@@ -8,6 +8,12 @@ export interface JsonSchemaArray extends JsonSchemaLeaf {
 export interface JsonSchemaTuple extends JsonSchemaLeaf {
     items: JsonSchemaNode[];
 }
+export interface JsonSchemaUnion extends JsonSchemaLeaf {
+    oneOf: JsonSchemaNode[];
+}
+export interface JsonSchemaLiteral extends JsonSchemaLeaf {
+    'const': string | number | boolean | null;
+}
 export interface JsonSchemaMap extends JsonSchemaLeaf {
     additionalProperties: JsonSchemaNode;
 }
@@ -16,7 +22,7 @@ export interface JsonSchemaObject extends JsonSchemaLeaf {
     required: string[];
     additionalProperties: boolean;
 }
-export type JsonSchemaNode = JsonSchemaLeaf | JsonSchemaArray | JsonSchemaTuple | JsonSchemaMap | JsonSchemaObject;
+export type JsonSchemaNode = JsonSchemaLeaf | JsonSchemaArray | JsonSchemaTuple | JsonSchemaMap | JsonSchemaObject | JsonSchemaUnion | JsonSchemaLiteral;
 export interface JsonSchema {
     $ref: string;
     $schema: string;
@@ -27,6 +33,7 @@ type ObjectDescriptionToType<T extends {}> = {
     readonly [x in keyof T]: UnwrapConfigDescriberLeaf<T[x]>;
 };
 type TraverseTuple<Ts extends any[]> = Ts extends [] ? [] : Ts extends [infer Head, ...infer Rest] ? [UnwrapConfigDescriberLeaf<Head>, ...TraverseTuple<Rest>] : never;
+type TraverseUnion<Ts extends any[]> = Ts extends [] ? never : Ts extends [infer Head, ...infer Rest] ? UnwrapConfigDescriberLeaf<Head> | TraverseUnion<Rest> : never;
 export interface ValidationSuccess<T> {
     success: true;
     value: T;
@@ -42,12 +49,19 @@ declare class ValidationBox<T> {
     static fail<T>(errorMessage: string): ValidationBox<T>;
     static ok<T>(value: T): ValidationBox<T>;
     success(): boolean;
-    unwrap(): T;
+    unwrap(message?: string): T;
     error(): string;
     get(): ValidationResult<T>;
     or<U>(x: U): ValidationBox<U | T>;
 }
-declare class ConfigDescriberLeaf<T> {
+export interface ConfigDescriberBaseConfig {
+    mergeStrategy: 'replace' | 'merge';
+}
+declare class ConfigDescriberBase {
+    $: ConfigDescriberBaseConfig;
+    onMerge(strategy: ConfigDescriberBaseConfig['mergeStrategy']): this;
+}
+declare class ConfigDescriberLeaf<T> extends ConfigDescriberBase {
     validate: (x: unknown) => ValidationBox<T>;
     printSchema: () => JsonSchemaNode;
     constructor(validate: (x: unknown) => ValidationBox<T>, printSchema: () => JsonSchemaNode);
@@ -60,6 +74,12 @@ declare class ConfigDescriberObjectLeaf<T> extends ConfigDescriberLeaf<T> {
     constructor(validate: (x: unknown) => ValidationBox<T>, printSchema: () => JsonSchemaNode, schema: Record<string, ConfigDescriberLeaf<T>>);
 }
 export type ConfigSchema<T> = ConfigDescriberLeaf<T>;
+export interface ConfigDescriberFieldInfo {
+    mergeStrategy: ConfigDescriberBaseConfig['mergeStrategy'];
+}
+export declare function inspectSchema(schema: ConfigDescriberLeaf<any>): {
+    inspectPath(name: string): ConfigDescriberFieldInfo | undefined;
+};
 export interface CommonBuilderConfig<T> {
     default?: T;
     description?: string;
@@ -77,8 +97,15 @@ export declare const D: {
     array<T_2>(type: ConfigDescriberLeaf<T_2>, initAsEmpty?: boolean): ConfigDescriberLeaf<T_2[]>;
     map<K_1, V>(keySchema: ConfigDescriberLeaf<K_1>, valSchema: ConfigDescriberLeaf<V>): ConfigDescriberLeaf<Map<K_1, V>>;
     tuple<Ts extends ConfigDescriberLeaf<any>[]>(...items: Ts): ConfigDescriberLeaf<TraverseTuple<Ts>>;
+    union<Ts_1 extends ConfigDescriberLeaf<any>[]>(...items: Ts_1): ConfigDescriberLeaf<TraverseUnion<Ts_1>>;
+    literal: {
+        string<T_3 extends string>(x: T_3): ConfigDescriberLeaf<T_3>;
+        number<T_4 extends number>(x: T_4): ConfigDescriberLeaf<T_4>;
+        boolean<T_5 extends boolean>(x: T_5): ConfigDescriberLeaf<T_5>;
+        null(x: null): ConfigDescriberLeaf<null>;
+    };
     combine<A, B>(a: ConfigDescriberObjectLeaf<A>, b: ConfigDescriberObjectLeaf<B>): ConfigDescriberObjectLeaf<A & B>;
-    printJSONSchema<T_3>(schema: ConfigDescriberLeaf<T_3>): string;
+    printJSONSchema<T_6>(schema: ConfigDescriberLeaf<T_6>): string;
 };
 export type ConfigTypeInfer<T> = UnwrapConfigDescriberLeaf<T>;
 export {};

package/build/lib/src/configDescriber.js CHANGED Viewed

@@ -26,11 +26,11 @@ class ValidationBox {
     success() {
         return this.box.success;
     }
-    unwrap() {
+    unwrap(message) {
         if (this.box.success) {
             return this.box.value;
         }
-        throw new Error("");
+        throw new Error(message !== null && message !== void 0 ? message : 'panic');
     }
     error() {
         if (!this.box.success) {
@@ -51,8 +51,20 @@ class ValidationBox {
         });
     }
 }
-class ConfigDescriberLeaf {
+class ConfigDescriberBase {
+    constructor() {
+        this.$ = {
+            mergeStrategy: 'merge'
+        };
+    }
+    onMerge(strategy) {
+        this.$.mergeStrategy = strategy;
+        return this;
+    }
+}
+class ConfigDescriberLeaf extends ConfigDescriberBase {
     constructor(validate, printSchema) {
+        super();
         this.validate = validate;
         this.printSchema = printSchema;
     }
@@ -66,6 +78,27 @@ class ConfigDescriberObjectLeaf extends ConfigDescriberLeaf {
         this.schema = schema;
     }
 }
+export function inspectSchema(schema) {
+    return {
+        inspectPath(name) {
+            if (name === '') {
+                return {
+                    mergeStrategy: schema.$.mergeStrategy
+                };
+            }
+            const path = name.split('.');
+            let leaf = schema;
+            while (leaf instanceof ConfigDescriberObjectLeaf && path.length > 0) {
+                const key = path.shift();
+                leaf = leaf.schema[key];
+                if (!leaf) {
+                    return undefined;
+                }
+            }
+            return { mergeStrategy: leaf.$.mergeStrategy };
+        }
+    };
+}
 function mk(typeName, check, config) {
     return new ConfigDescriberLeaf(x => {
         if (check(x)) {
@@ -262,6 +295,71 @@ export const D = {
             };
         });
     },
+    union(...items) {
+        return new ConfigDescriberLeaf(xs => {
+            for (const item of items) {
+                const r = item.validate(xs);
+                if (r.success()) {
+                    return r;
+                }
+            }
+            return ValidationBox.fail('Not matched');
+        }, () => {
+            return {
+                oneOf: items.map(it => it.printSchema())
+            };
+        });
+    },
+    literal: {
+        string(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'string' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        number(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'number' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        boolean(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'boolean' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        null(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'object' && xs === null) {
+                    return ValidationBox.ok(null);
+                }
+                return ValidationBox.fail('Expected null');
+            }, () => {
+                return {
+                    'const': null
+                };
+            });
+        }
+    },
     ////////////////////////////////////////
     // Utils
     combine(a, b) {

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

@@ -13,7 +13,7 @@
  * 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, getSuperType, IDLAnyType, IDLContainerUtils, DebugUtils, mixMethodParametersAndTags, createReferenceType, transformMethodsAsync2ReturnPromise, 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 } 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, getSuperType, 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 { resolveSyntheticType, toIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
@@ -64,7 +64,7 @@ export class CustomPrintVisitor {
         else {
             throw new Error(`Unexpected node kind: ${IDLKind[node.kind]}`);
         }
-        for (const namespace of namespacesPath) {
+        for (const _ of namespacesPath) {
             this.popIndent();
             this.print("}");
         }
@@ -86,9 +86,6 @@ export class CustomPrintVisitor {
     printInterface(node) {
         var _a;
         let typeSpec = this.toTypeName(node);
-        // Workaround for an SDK declaration clash between `WrappedBuilder` and `ContentModifier`
-        if (node.name === "WrappedBuilder")
-            typeSpec = "WrappedBuilder<Args extends any[]>";
         const entity = (_a = getExtAttribute(node, IDLExtendedAttributes.Entity)) !== null && _a !== void 0 ? _a : IDLEntity.Interface;
         if (entity === IDLEntity.Literal) {
             this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, false, true)}`);
@@ -99,6 +96,9 @@ export class CustomPrintVisitor {
         else if (entity === IDLEntity.NamedTuple) {
             this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${this.literal(node, true, true)}`);
         }
+        else if (entity === IDLEntity.Intersection) {
+            this.print(`${isInNamespace(node) ? "" : "declare "}type ${typeSpec} = ${node.inheritance.map(it => this.printTypeForTS(it)).join(' & ')}`);
+        }
         else {
             let interfaces = node.inheritance;
             let keyword = "extends";
@@ -152,8 +152,11 @@ export class CustomPrintVisitor {
     }
     paramText(paramOrTag) {
         const param = paramOrTag;
-        if (param.kind === IDLKind.Parameter)
-            return `${param.isVariadic ? "..." : ""}${getName(param)}${param.isOptional ? "?" : ""}: ${this.printTypeForTS(param.type)}`;
+        if (param.kind === IDLKind.Parameter) {
+            const dots = param.isVariadic ? "..." : "";
+            const brackets = param.isVariadic ? "[]" : "";
+            return `${dots}${getName(param)}${param.isOptional ? "?" : ""}: ${this.printTypeForTS(param.type)}${brackets}`;
+        }
         const tag = paramOrTag;
         return `${tag.name}: ${tag.value}`;
     }
@@ -280,6 +283,7 @@ export class CustomPrintVisitor {
                 case IDLNumberType:
                     return "number";
                 case IDLAnyType: return "any";
+                case IDLObjectType: return "Object";
                 case IDLUnknownType: return "unknown";
                 case IDLBufferType: return "ArrayBuffer";
                 case IDLBooleanType: return "boolean";
@@ -290,6 +294,7 @@ export class CustomPrintVisitor {
                 case IDLBigintType:
                 case IDLPointerType: return "number|bigint";
                 case IDLDate: return "Date";
+                case IDLFunctionType: return "Function";
                 default: throw new Error(`Unknown primitive type ${DebugUtils.debugPrintType(type)}`);
             }
         }
@@ -311,15 +316,21 @@ export class CustomPrintVisitor {
     toTypeName(node) {
         var _a, _b;
         if (isReferenceType(node)) {
-            const synthDecl = this.resolver(node);
-            if (synthDecl && isSyntheticEntry(synthDecl)) {
-                if (isInterface(synthDecl)) {
-                    const isTuple = getExtAttribute(synthDecl, IDLExtendedAttributes.Entity) === IDLEntity.Tuple;
-                    return this.literal(synthDecl, isTuple, !isTuple);
-                }
-                if (isCallback(synthDecl)) {
-                    return this.callback(synthDecl);
+            const decl = this.resolver(node);
+            if (decl) {
+                if (isSyntheticEntry(decl)) {
+                    if (isInterface(decl)) {
+                        const isTuple = getExtAttribute(decl, IDLExtendedAttributes.Entity) === IDLEntity.Tuple;
+                        return this.literal(decl, isTuple, !isTuple);
+                    }
+                    if (isCallback(decl)) {
+                        return this.callback(decl);
+                    }
                 }
+                let typeSpec = getQualifiedName(decl, "namespace.name");
+                if (node.typeArguments)
+                    typeSpec = `${typeSpec}<${node.typeArguments.map(it => this.printTypeForTS(it))}>`;
+                return typeSpec;
             }
         }
         if (hasExtAttribute(node, IDLExtendedAttributes.Import)) {
@@ -329,7 +340,7 @@ export class CustomPrintVisitor {
         if ((isInterface(node) || isCallback(node) || isTypedef(node)) && ((_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.length))
             typeSpec = `${typeSpec}<${(_b = node.typeParameters) === null || _b === void 0 ? void 0 : _b.join(",")}>`;
         if (isReferenceType(node) && node.typeArguments)
-            typeSpec = `${typeSpec}<${node.typeArguments.map(it => this.toTypeName(it))}>`;
+            typeSpec = `${typeSpec}<${node.typeArguments.map(it => this.printTypeForTS(it))}>`;
         return typeSpec;
     }
     callback(node) {
@@ -345,10 +356,12 @@ export class CustomPrintVisitor {
 }
 export function idlToDtsString(name, content) {
     let printer = new CustomPrintVisitor(resolveSyntheticType, Language.TS);
-    const idlFile = toIDLFile(name, content);
+    const [idlFile] = toIDLFile(name, { content });
     printer.printPackage(idlFile);
-    idlFile.entries.forEach(it => {
+    linearizeNamespaceMembers(idlFile.entries).forEach(it => {
         transformMethodsAsync2ReturnPromise(it);
+    });
+    idlFile.entries.forEach(it => {
         printer.visit(it);
     });
     return printer.output.join("\n");

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

@@ -1,24 +1,57 @@
 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,
+    REFERENCE_IS_NOT_RESOLVED = 1002
+}
+type IDLValidationErrorDescriptionBox = Record<IDLValidationDiagnosticsCode, string>;
+export declare const IDLValidationErrorDescription: {
+    en_EN: IDLValidationErrorDescriptionBox;
+};
 export interface IDLLinterOptions {
     validEntryAttributes: Map<idl.IDLKind, string[]>;
     checkEnumsConsistency: boolean;
     checkReferencesResolved: boolean;
 }
+interface IDLLinterContextRecord {
+    typeParameters: Set<string>;
+}
+declare class IDLLinterContext {
+    private stack;
+    constructor();
+    enter(rec: IDLLinterContextRecord): void;
+    leave(): void;
+    get current(): IDLLinterContextRecord;
+    hasTypeParameter(name: string): boolean;
+}
 export declare class IDLLinter {
-    protected node: idl.IDLNode;
+    protected file: idl.IDLFile;
     protected resolver: ReferenceResolver;
     protected options: IDLLinterOptions;
-    constructor(node: idl.IDLNode, resolver: ReferenceResolver, options: IDLLinterOptions);
-    private entryErrors;
-    private pushError;
-    result: string;
-    visit(): string;
+    protected info?: IDLTokenInfoMap | undefined;
+    protected context: IDLLinterContext;
+    diagnostics: IDLLinterDiagnosticsSummary[];
+    constructor(file: idl.IDLFile, resolver: ReferenceResolver, options: IDLLinterOptions, info?: IDLTokenInfoMap | undefined);
+    visit(): IDLLinterDiagnosticsSummary[];
+    protected enter(node: idl.IDLNode): (() => void) | undefined;
     protected check(node: idl.IDLNode): void;
     protected checkValidAttributes(entry: idl.IDLEntry, validAttributes: string[]): void;
     protected checkEnumConsistency(entry: idl.IDLEnum): void;
     private static builtinReferences;
     protected checkReferenceResolved(reference: idl.IDLReferenceType): void;
 }
-export declare function verifyIDLLinter(node: idl.IDLNode, resolver: ReferenceResolver, options: IDLLinterOptions): true;
+interface IDLLinterDiagnosticsSummary {
+    code: IDLValidationDiagnosticsCode;
+    message: string;
+    file: string;
+    position: [number, number];
+}
+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 {};
 //# sourceMappingURL=IDLLinter.d.ts.map