@ts-for-gir/lib 3.0.0-beta.11

package/lib/types/type-gir-enumeration.d.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript enumeration */
+export type TypeGirEnumeration = 'enum' | 'bitfield';

package/lib/types/type-gir-enumeration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-enumeration.js.map

package/lib/types/type-gir-enumeration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-enumeration.js","sourceRoot":"","sources":["../../src/types/type-gir-enumeration.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-function.d.ts

@@ -0,0 +1 @@
+export type TypeGirFunction = 'constructor' | 'function' | 'method' | 'static-function' | 'signal' | 'virtual' | 'callback';

package/lib/types/type-gir-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-function.js.map

package/lib/types/type-gir-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-function.js","sourceRoot":"","sources":["../../src/types/type-gir-function.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-interface.d.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript interface */
+export type TypeGirInterface = 'callback';

package/lib/types/type-gir-interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-interface.js.map

package/lib/types/type-gir-interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-interface.js","sourceRoot":"","sources":["../../src/types/type-gir-interface.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-method.d.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript method (or static function) of a class */
+export type TypeGirMethod = 'virtual' | 'signal' | 'method' | 'constructor' | 'function' | 'static';

package/lib/types/type-gir-method.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-method.js.map

package/lib/types/type-gir-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-method.js","sourceRoot":"","sources":["../../src/types/type-gir-method.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-parameter.d.ts

@@ -0,0 +1 @@
+export type TypeGirParameter = 'callable-param';

package/lib/types/type-gir-parameter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-parameter.js.map

package/lib/types/type-gir-parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-parameter.js","sourceRoot":"","sources":["../../src/types/type-gir-parameter.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-property.d.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript field / property */
+export type TypeGirProperty = 'property' | 'field' | 'constant';

package/lib/types/type-gir-property.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-property.js.map

package/lib/types/type-gir-property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-property.js","sourceRoot":"","sources":["../../src/types/type-gir-property.ts"],"names":[],"mappings":""}

package/lib/types/type-gir-variable.d.ts

@@ -0,0 +1 @@
+export type TypeGirVariable = 'constant';

package/lib/types/type-gir-variable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-gir-variable.js.map

package/lib/types/type-gir-variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-gir-variable.js","sourceRoot":"","sources":["../../src/types/type-gir-variable.ts"],"names":[],"mappings":""}

package/lib/types/type-ts-element.d.ts

@@ -0,0 +1,3 @@
+import { TypeTsFunction, TypeTsProperty } from './index.js';
+/** Any typescript element type */
+export type TypeTsElement = 'class' | 'interface' | 'enum' | 'enum-member' | 'constant' | 'event-methods' | 'type' | TypeTsFunction | TypeTsProperty;

package/lib/types/type-ts-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-ts-element.js.map

package/lib/types/type-ts-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-ts-element.js","sourceRoot":"","sources":["../../src/types/type-ts-element.ts"],"names":[],"mappings":""}

package/lib/types/type-ts-enumeration-member.d.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript enumeration */
+export type TypeTsEnumerationMember = 'enum-member';

package/lib/types/type-ts-enumeration-member.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-ts-enumeration-member.js.map

package/lib/types/type-ts-enumeration-member.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-ts-enumeration-member.js","sourceRoot":"","sources":["../../src/types/type-ts-enumeration-member.ts"],"names":[],"mappings":""}

package/lib/types/type-ts-function.d.ts

@@ -0,0 +1 @@
+export type TypeTsFunction = 'static-function' | 'constructor' | 'function' | 'method' | 'event-methods' | 'interface';

package/lib/types/type-ts-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-ts-function.js.map

package/lib/types/type-ts-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-ts-function.js","sourceRoot":"","sources":["../../src/types/type-ts-function.ts"],"names":[],"mappings":""}

package/lib/types/type-ts-property.d.ts

@@ -0,0 +1 @@
+export type TypeTsProperty = 'static-property' | 'property' | 'constructor-property';

package/lib/types/type-ts-property.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-ts-property.js.map

package/lib/types/type-ts-property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-ts-property.js","sourceRoot":"","sources":["../../src/types/type-ts-property.ts"],"names":[],"mappings":""}

package/lib/types/user-config-load-result.d.ts

@@ -0,0 +1,6 @@
+import { UserConfig } from './user-config';
+export interface UserConfigLoadResult {
+    config: Partial<UserConfig>;
+    filepath: string;
+    isEmpty?: boolean | undefined;
+}

package/lib/types/user-config-load-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user-config-load-result.js.map

package/lib/types/user-config-load-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-config-load-result.js","sourceRoot":"","sources":["../../src/types/user-config-load-result.ts"],"names":[],"mappings":""}

package/lib/types/user-config.d.ts

@@ -0,0 +1,42 @@
+import { BuildType, Environment, ModuleType } from './index.js';
+/**
+ * Types for config file
+ */
+export interface UserConfig {
+    /** javascript environment */
+    environments: Environment[];
+    /** directory to output to */
+    outdir: string | null;
+    /** Definitions generation type */
+    buildType?: BuildType;
+    /** Module type, can be CommonJS or ESM */
+    moduleType?: ModuleType;
+    /** GIR directories */
+    girDirectories: string[];
+    /** Switch on/off the verbose mode */
+    verbose: boolean;
+    /** Do not ask for package versions if multiple versions are found */
+    ignoreVersionConflicts: boolean;
+    /** print the output to console and create no files */
+    print: boolean;
+    /** GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules */
+    modules: string[];
+    /** modules that should be ignored */
+    ignore?: string[];
+    /** Do not export all symbols for each module as a namespace */
+    noNamespace: boolean;
+    /** Do not generate documentation comments */
+    noComments: boolean;
+    /** Do not generate debugging inline comments */
+    noDebugComments: boolean;
+    /** Fix Inheritance and implementation type conflicts */
+    fixConflicts: boolean;
+    /** Disables the generation of types that are in conflict with the DOM types */
+    noDOMLib: boolean;
+    /** Generate types for GNOME Shell */
+    gnomeShellTypes: boolean;
+    /** Generate a tsconfig alias */
+    generateAlias: boolean;
+    /** Generate promisified functions for async/finish calls */
+    promisify: boolean;
+}

package/lib/types/user-config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user-config.js.map

package/lib/types/user-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-config.js","sourceRoot":"","sources":["../../src/types/user-config.ts"],"names":[],"mappings":""}

package/lib/utils.d.ts

@@ -0,0 +1,262 @@
+import lodash from 'lodash';
+import { Environment, GirInfoAttrs, TsType, FileInfo } from './types/index.js';
+import { inspect } from 'util';
+export { inspect };
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are **not** supported.
+ *
+ * @category Lang
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ * var other = { 'user': 'fred' };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+export declare const isEqual: (value: any, other: any) => boolean;
+/**
+ * Creates an array of values by running each element in collection through iteratee. The iteratee is
+ * invoked with three arguments: (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues,
+ * _.reject, and _.some.
+ *
+ * The guarded methods are:
+ * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max,
+ * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,
+ * sample, some, sum, uniq, and words
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @return Returns the new mapped array.
+ */
+export declare const map: {
+    <T, TResult>(collection: T[] | null | undefined, iteratee: lodash.ArrayIterator<T, TResult>): TResult[];
+    <T_1, TResult_1>(collection: lodash.List<T_1> | null | undefined, iteratee: lodash.ListIterator<T_1, TResult_1>): TResult_1[];
+    <T_2>(collection: lodash.Dictionary<T_2> | lodash.NumericDictionary<T_2> | null | undefined): T_2[];
+    <T_3 extends object, TResult_2>(collection: T_3 | null | undefined, iteratee: lodash.ObjectIterator<T_3, TResult_2>): TResult_2[];
+    <T_4, K extends keyof T_4>(collection: lodash.Dictionary<T_4> | lodash.NumericDictionary<T_4> | null | undefined, iteratee: K): T_4[K][];
+    <T_5>(collection: lodash.Dictionary<T_5> | lodash.NumericDictionary<T_5> | null | undefined, iteratee?: string | undefined): any[];
+    <T_6>(collection: lodash.Dictionary<T_6> | lodash.NumericDictionary<T_6> | null | undefined, iteratee?: object | undefined): boolean[];
+};
+/**
+ * Iterates over elements of collection, returning the first element predicate returns truthy for.
+ * The predicate is invoked with three arguments: (value, index|key, collection).
+ *
+ * @param collection The collection to search.
+ * @param predicate The function invoked per iteration.
+ * @param fromIndex The index to search from.
+ * @return Returns the matched element, else undefined.
+ */
+export declare const find: {
+    <T, S extends T>(collection: lodash.List<T> | null | undefined, predicate: lodash.ListIteratorTypeGuard<T, S>, fromIndex?: number | undefined): S | undefined;
+    <T_1>(collection: lodash.List<T_1> | null | undefined, predicate?: lodash.ListIterateeCustom<T_1, boolean> | undefined, fromIndex?: number | undefined): T_1 | undefined;
+    <T_2 extends object, S_1 extends T_2[keyof T_2]>(collection: T_2 | null | undefined, predicate: lodash.ObjectIteratorTypeGuard<T_2, S_1>, fromIndex?: number | undefined): S_1 | undefined;
+    <T_3 extends object>(collection: T_3 | null | undefined, predicate?: lodash.ObjectIterateeCustom<T_3, boolean> | undefined, fromIndex?: number | undefined): T_3[keyof T_3] | undefined;
+};
+/**
+ * Recursively merges own and inherited enumerable properties of source
+ * objects into the destination object, skipping source properties that resolve
+ * to `undefined`. Array and plain object properties are merged recursively.
+ * Other objects and value types are overridden by assignment. Source objects
+ * are applied from left to right. Subsequent sources overwrite property
+ * assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @category Object
+ * @param object The destination object.
+ * @param [sources] The source objects.
+ * @returns Returns `object`.
+ * @example
+ *
+ * var users = {
+ *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
+ * };
+ *
+ * var ages = {
+ *   'data': [{ 'age': 36 }, { 'age': 40 }]
+ * };
+ *
+ * _.merge(users, ages);
+ * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
+ */
+export declare const merge: {
+    <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
+    <TObject_1, TSource1, TSource2>(object: TObject_1, source1: TSource1, source2: TSource2): TObject_1 & TSource1 & TSource2;
+    <TObject_2, TSource1_1, TSource2_1, TSource3>(object: TObject_2, source1: TSource1_1, source2: TSource2_1, source3: TSource3): TObject_2 & TSource1_1 & TSource2_1 & TSource3;
+    <TObject_3, TSource1_2, TSource2_2, TSource3_1, TSource4>(object: TObject_3, source1: TSource1_2, source2: TSource2_2, source3: TSource3_1, source4: TSource4): TObject_3 & TSource1_2 & TSource2_2 & TSource3_1 & TSource4;
+    (object: any, ...otherArgs: any[]): any;
+};
+/**
+ * Creates a shallow clone of value.
+ *
+ * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays,
+ * array buffers, booleans, date objects, maps, numbers, Object objects, regex's, sets, strings, symbols,
+ * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty
+ * object is returned for not cloneable values such as error objects, functions, DOM nodes, and WeakMaps.
+ *
+ * @param value The value to clone.
+ * @return Returns the cloned value.
+ */
+export declare const clone: <T>(value: T) => T;
+/**
+ * This method is like clone except that it recursively clones value.
+ *
+ * @param value The value to recursively clone.
+ * @return Returns the deep cloned value.
+ */
+export declare const cloneDeep: <T>(value: T) => T;
+/**
+ * Split a package name into namespace and version
+ */
+export declare const splitModuleName: (packageName: string) => {
+    packageName: string;
+    namespace: string;
+    version: string;
+};
+/** Remove namespace prefix */
+export declare const removeNamespace: (type: string, namespace: string) => string;
+/** Remove class module name prefix */
+export declare const removeClassModule: (type: string, namespace: string) => string;
+/**
+ * Add namespace prefix
+ */
+export declare const addNamespace: (type: string, namespace: string) => string;
+/**
+ * Checking whether some variable is iterable
+ * @see https://stackoverflow.com/a/32538867
+ * @param obj Variable to check for iterable
+ * @returns Whether the variable is iterable or not
+ */
+export declare const isIterable: (obj: unknown[]) => boolean;
+/**
+ * Checking whether a string is numeric
+ * @param str The string to check
+ * @returns Whether the string is numeric or not
+ */
+export declare const isNumeric: (str: string) => boolean;
+/**
+ * Get the first character of a string
+ * @param str The string to get the first character from
+ * @returns The first character
+ */
+export declare const getFirstChar: (str: string) => string;
+/**
+ * Get the last character of a string
+ * @param str The string to get the last character from
+ * @returns The last character
+ */
+export declare const getLastChar: (str: string) => string;
+/**
+ * Check if the first character of a string is numeric
+ * @param str The string to check
+ * @returns Whether the first character is numeric or not
+ */
+export declare const isFirstCharNumeric: (str: string) => boolean;
+/**
+ * Convert a string to camelCase
+ * @param str The string to convert
+ * @returns The converted string
+ */
+export declare const camelCase: (str: string) => string;
+/**
+ * Convert a string to lowerCamelCase
+ * @param str The string to convert
+ * @returns The converted string
+ */
+export declare const lowerCamelCase: (str: string) => string;
+/**
+ * Convert a string to UpperCamelCase
+ * @param str The string to convert
+ * @returns The converted string
+ */
+export declare const upperCamelCase: (str: string) => string;
+/**
+ * Find a file in a list of directories
+ * @param dirs The directories to search in
+ * @param filename The filename to search for
+ * @returns The file info
+ */
+export declare const findFileInDirs: (dirs: string[], filename: string) => FileInfo;
+/**
+ * Union (a ∪ b): create a set that contains the elements of both set a and set b.
+ * See https://2ality.com/2015/01/es6-set-operations.html#union
+ * @param target
+ * @param source
+ */
+export declare const union: <T>(target: Set<T> | T[], source: Set<T> | T[]) => Set<T>;
+export declare const stripParamNames: (func: string, ignoreTail?: boolean) => string;
+/**
+ * Check if a line is a comment line
+ * @param line The line to check
+ * @returns Whether the line is a comment line or not
+ */
+export declare const isCommentLine: (line: string) => boolean;
+/**
+ * Add indents to a string
+ * @param indents The number of indents
+ * @param spaceForIndent The number of spaces for each indent
+ * @returns The indented string
+ */
+export declare const generateIndent: (indents?: number, spaceForIndent?: number) => string;
+export declare const __filename: string;
+export declare const __dirname: string;
+/**
+ * Get the output or input directory of the environment
+ * @param environment The environment to get the directory for
+ * @param baseDir The base directory
+ * @returns The path to the directory
+ */
+export declare const getEnvironmentDir: (environment: Environment, baseDir: string) => string;
+/**
+ * Get the destination path for the environment
+ * @param environment The environment to get the destination path for
+ * @param outputDir The output directory
+ * @param parts The path parts
+ * @returns The destination path
+ */
+export declare const getDestPath: (environment: Environment, outputDir: string, ...parts: string[]) => string;
+/**
+ * Convert a GirBoolean to a boolean
+ * @param boolStr The GirBoolean string
+ * @param defaultVal The default value
+ * @returns The boolean value
+ */
+export declare const girBool: (boolStr: string | undefined, defaultVal?: boolean) => boolean;
+/**
+ * Returns `true` if the definitions in `d1` and `d2` have equivalent signatures
+ * @param d1
+ * @param d2
+ */
+export declare const signaturesMatch: (d1: string, d2: string) => boolean;
+/**
+ * GirElements contains an attribute `introspectable`, which is a GirBoolean.
+ * If this is attribute is falsy the element is not introspectable,
+ * this means doesn't exist in the bindings, due in general to missing information in the annotations in the original C code
+ */
+export declare const girElementIsIntrospectable: (girElement?: {
+    $: GirInfoAttrs & {
+        name: string;
+    };
+} | undefined, name?: string) => boolean;
+/**
+ * Check if a type is optional
+ * @param types The types to check
+ * @returns Whether the type is optional or not
+ */
+export declare const typeIsOptional: (types: TsType[]) => boolean;