@gtkx/codegen 0.21.0 → 1.0.0-rc.1

package/src/analysis/inheritance.ts

@@ -0,0 +1,242 @@
+import { lowerFirst, toCamelCase, toCamelIdentifier, toPascalCase } from "@gtkx/utils";
+import { ancestorChain, type ResolvedAncestor, resolveInterface } from "../gir/ancestry.js";
+import type { GirClass } from "../gir/class.js";
+import type { GirFunction } from "../gir/function.js";
+import type { Library } from "../gir/library.js";
+import type { GirProperty } from "../gir/property.js";
+import type { TypeId } from "../gir/type-id.js";
+import { methodExportName } from "../store/gi/method.js";
+import { resolveAccessorType } from "../store/gi/property-accessor.js";
+import type { ModuleContext } from "../writer/context.js";
+import { inputParameters } from "./param-structure.js";
+import { renderTsType } from "./ts-type.js";
+
+type AncestryContext = {
+    library: Library;
+    namespace: { name: string };
+};
+
+export const resolveImplementedInterface = (
+    context: AncestryContext,
+    name: string,
+    defaultNamespace: string = context.namespace.name,
+): ResolvedAncestor | undefined => resolveInterface(context.library, defaultNamespace, name);
+
+const resolveDirectInterfaces = (
+    context: AncestryContext,
+    klass: GirClass,
+    defaultNamespace: string,
+): ResolvedAncestor[] => {
+    const interfaces: ResolvedAncestor[] = [];
+    for (const implementName of klass.implements) {
+        const iface = resolveImplementedInterface(context, implementName, defaultNamespace);
+        if (iface !== undefined) interfaces.push(iface);
+    }
+    return interfaces;
+};
+
+export const resolvePrerequisiteReference = (context: ModuleContext, name: string): string | undefined => {
+    const resolved = context.library.resolveType(context.namespace.name, name);
+    if (resolved === undefined) return undefined;
+    if (resolved.kind !== "interface" && resolved.kind !== "class") return undefined;
+    return context.qualify(resolved.namespace.name, toPascalCase(resolved.value.name));
+};
+
+export const forEachAncestor = (
+    context: AncestryContext,
+    klass: GirClass,
+    visit: (ancestor: ResolvedAncestor, interfaces: ResolvedAncestor[]) => void,
+    stop: (ancestor: GirClass) => boolean = () => false,
+): void => {
+    let first = true;
+    for (const ancestor of ancestorChain(context.library, klass, context.namespace.name)) {
+        if (first) {
+            first = false;
+            continue;
+        }
+        if (stop(ancestor.klass)) break;
+        visit(ancestor, resolveDirectInterfaces(context, ancestor.klass, ancestor.namespaceName));
+    }
+};
+
+const forEachInheritedProperty = (
+    context: ModuleContext,
+    klass: GirClass,
+    visit: (owner: GirClass, property: GirProperty) => void,
+): void => {
+    forEachAncestor(context, klass, (ancestor, interfaces) => {
+        for (const property of ancestor.klass.properties) visit(ancestor.klass, property);
+        for (const iface of interfaces) {
+            for (const property of iface.klass.properties) visit(iface.klass, property);
+        }
+    });
+};
+
+export type OwnedProperty = { owner: GirClass; property: GirProperty };
+
+export const collectInterfaceProperties = (context: ModuleContext, klass: GirClass): OwnedProperty[] => {
+    const seen = new Set<string>();
+    for (const property of klass.properties) seen.add(toCamelIdentifier(property.name));
+    forEachInheritedProperty(context, klass, (_owner, property) => seen.add(toCamelIdentifier(property.name)));
+    const result: OwnedProperty[] = [];
+    for (const iface of resolveDirectInterfaces(context, klass, context.namespace.name)) {
+        for (const property of iface.klass.properties) {
+            const name = toCamelIdentifier(property.name);
+            if (seen.has(name)) continue;
+            seen.add(name);
+            result.push({ owner: iface.klass, property });
+        }
+    }
+    return result;
+};
+
+type MethodSignature = { returnType: string; arity: number };
+
+const ancestorClassMethodSignatures = (context: ModuleContext, klass: GirClass): Map<string, MethodSignature> => {
+    const signatures = new Map<string, MethodSignature>();
+    forEachAncestor(context, klass, (ancestor) => {
+        for (const method of ancestor.klass.methods) {
+            if (!method.introspectable) continue;
+            const name = toCamelCase(method.name);
+            if (signatures.has(name)) continue;
+            signatures.set(name, {
+                returnType: renderTsType(context, method.returnValue.type, method.returnValue.nullable),
+                arity: inputParameters(context.library, method).length,
+            });
+        }
+    });
+    return signatures;
+};
+
+export const collectInterfaceMergeOmissions = (
+    context: ModuleContext,
+    klass: GirClass,
+    iface: { klass: GirClass; namespaceName: string },
+): string[] => {
+    const ancestors = ancestorClassMethodSignatures(context, klass);
+    const omissions: string[] = [];
+    for (const method of iface.klass.methods) {
+        if (!method.introspectable) continue;
+        const name = toCamelCase(method.name);
+        const ancestor = ancestors.get(name);
+        if (ancestor === undefined) continue;
+        const returnType = renderTsType(context, method.returnValue.type, method.returnValue.nullable);
+        const arity = inputParameters(context.library, method).length;
+        if (ancestor.returnType !== returnType || ancestor.arity !== arity) omissions.push(name);
+    }
+    return omissions;
+};
+
+export const collectInheritedPropertyTypes = (context: ModuleContext, klass: GirClass): Map<string, string> => {
+    const types = new Map<string, string>();
+    const record = (owner: GirClass, property: GirProperty): void => {
+        const jsName = toCamelIdentifier(property.name);
+        if (types.has(jsName)) return;
+        const tsType = resolveAccessorType(context, property, owner.methods);
+        if (tsType !== undefined) types.set(jsName, tsType);
+    };
+    forEachInheritedProperty(context, klass, record);
+    return types;
+};
+
+type InheritedMethod = {
+    method: GirFunction;
+    namespaceName: string;
+};
+
+export type InheritedMethods = {
+    returnTypes: Map<string, string>;
+    definitions: Map<string, InheritedMethod>;
+};
+
+export const collectInheritedMethods = (context: ModuleContext, klass: GirClass): InheritedMethods => {
+    const accumulator: InheritedMethods = {
+        returnTypes: new Map<string, string>(),
+        definitions: new Map<string, InheritedMethod>(),
+    };
+    for (const iface of resolveDirectInterfaces(context, klass, context.namespace.name)) {
+        absorbInheritedMethods(context, iface, accumulator);
+    }
+    forEachAncestor(context, klass, (ancestor, interfaces) => {
+        absorbInheritedMethods(context, ancestor, accumulator);
+        for (const iface of interfaces) absorbInheritedMethods(context, iface, accumulator);
+    });
+    return accumulator;
+};
+
+const absorbInheritedMethods = (
+    context: ModuleContext,
+    resolved: { klass: GirClass; namespaceName: string },
+    accumulator: InheritedMethods,
+): void => {
+    const { returnTypes, definitions } = accumulator;
+    for (const method of resolved.klass.methods) {
+        if (!method.introspectable) continue;
+        const name = toCamelCase(method.name);
+        if (returnTypes.has(name)) continue;
+        definitions.set(name, { method, namespaceName: resolved.namespaceName });
+        returnTypes.set(name, renderTsType(context, method.returnValue.type, method.returnValue.nullable));
+    }
+};
+
+const RESERVED_SIGNAL_MEMBERS = new Set([
+    "connect",
+    "disconnect",
+    "emit",
+    "on",
+    "once",
+    "off",
+    "addEventListener",
+    "removeEventListener",
+]);
+
+export const conflictRename = (
+    context: ModuleContext,
+    callable: GirFunction,
+    inherited: InheritedMethods,
+    className: string,
+): string | undefined => {
+    if (!callable.introspectable) return undefined;
+    const name = methodExportName(callable);
+    if (RESERVED_SIGNAL_MEMBERS.has(name)) return conflictingMethodName(className, callable.name);
+    const inheritedReturn = inherited.returnTypes.get(name);
+    const inheritedMethod = inherited.definitions.get(name);
+    if (inheritedReturn === undefined || inheritedMethod === undefined) return undefined;
+    const ownReturn = renderTsType(context, callable.returnValue.type, callable.returnValue.nullable);
+    const conflicts =
+        inheritedReturn !== ownReturn ||
+        hasParameterEnumConflict(context, callable, inheritedMethod) ||
+        inputParameters(context.library, callable).length !==
+            inputParameters(context.library, inheritedMethod.method).length;
+    return conflicts ? conflictingMethodName(className, callable.name) : undefined;
+};
+
+const conflictingMethodName = (className: string, methodName: string): string =>
+    `${lowerFirst(className)}${toPascalCase(methodName)}`;
+
+export const reservedSignalMemberRename = (className: string, callable: GirFunction): string | undefined =>
+    RESERVED_SIGNAL_MEMBERS.has(methodExportName(callable))
+        ? conflictingMethodName(className, callable.name)
+        : undefined;
+
+const hasParameterEnumConflict = (context: ModuleContext, own: GirFunction, inherited: InheritedMethod): boolean => {
+    const ownParams = inputParameters(context.library, own);
+    const inheritedParams = inputParameters(context.library, inherited.method);
+    const count = Math.min(ownParams.length, inheritedParams.length);
+    for (let index = 0; index < count; index += 1) {
+        const ownParam = ownParams[index];
+        const inheritedParam = inheritedParams[index];
+        if (ownParam === undefined || inheritedParam === undefined) continue;
+        const ownEnum = enumIdentity(context, ownParam.parameter.type);
+        const inheritedEnum = enumIdentity(context, inheritedParam.parameter.type);
+        if (ownEnum !== undefined && inheritedEnum !== undefined && ownEnum !== inheritedEnum) return true;
+    }
+    return false;
+};
+
+const enumIdentity = (context: ModuleContext, ref: TypeId | undefined): string | undefined => {
+    if (ref === undefined) return undefined;
+    const resolved = context.library.typeOf(ref);
+    if (resolved?.kind !== "enum") return undefined;
+    return `${resolved.namespace.name}.${resolved.value.name}`;
+};

package/src/analysis/param-structure.ts

@@ -0,0 +1,127 @@
+import { toCamelIdentifier } from "@gtkx/utils";
+import type { GirFunction } from "../gir/function.js";
+import type { Library } from "../gir/library.js";
+import { type GirParameter, type GirSignal, isCallerAllocatedOut, isOutParameter } from "../gir/parameter.js";
+import type { TypeId } from "../gir/type-id.js";
+import { isCellInout, omitsPrimaryReturn } from "./descriptor-render.js";
+
+type InputParameter = {
+    parameter: GirParameter;
+    index: number;
+};
+
+export const inputParameters = (library: Library, fn: GirFunction): InputParameter[] => {
+    const lengthIndices = arrayLengthIndices(library, fn);
+    const closureIndices = closureAndDestroyIndices(fn);
+    const result: InputParameter[] = [];
+    fn.parameters.forEach((parameter, index) => {
+        if (parameter.isVarargs) return;
+        if (isOutParameter(parameter)) return;
+        if (isCallerAllocatedOut(parameter)) return;
+        if (lengthIndices.has(index)) return;
+        if (closureIndices.has(index)) return;
+        result.push({ parameter, index });
+    });
+    return result;
+};
+
+export const closureAndDestroyIndices = (fn: GirFunction): Set<number> => {
+    const indices = new Set<number>();
+    for (const parameter of fn.parameters) {
+        if (parameter.closureIndex !== undefined) indices.add(parameter.closureIndex);
+        if (parameter.destroyIndex !== undefined) indices.add(parameter.destroyIndex);
+    }
+    return indices;
+};
+
+const arrayLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+    const map = arrayLengthSources(library, fn);
+    return new Set(map.keys());
+};
+
+export const arrayLengthSources = (library: Library, fn: GirFunction): Map<number, number> => {
+    const map = new Map<number, number>();
+    fn.parameters.forEach((parameter, index) => {
+        const type = parameter.type === undefined ? undefined : library.typeOf(parameter.type);
+        if (type?.kind !== "carray") return;
+        const lengthIndex = type.lengthParameterIndex;
+        if (lengthIndex === undefined) return;
+        map.set(lengthIndex, index);
+    });
+    return map;
+};
+
+export const hasCallerAllocatedArrayLength = (library: Library, fn: GirFunction): boolean => {
+    for (const arrayIndex of arrayLengthSources(library, fn).values()) {
+        const array = fn.parameters[arrayIndex];
+        if (array !== undefined && isCallerAllocatedOut(array)) return true;
+    }
+    return false;
+};
+
+const returnArrayLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+    const returnType = fn.returnValue.type === undefined ? undefined : library.typeOf(fn.returnValue.type);
+    if (returnType?.kind !== "carray") return new Set();
+    const lengthIndex = returnType.lengthParameterIndex;
+    if (lengthIndex === undefined) return new Set();
+    return new Set([lengthIndex]);
+};
+
+export const foldedLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+    const indices = new Set<number>(arrayLengthSources(library, fn).keys());
+    for (const index of returnArrayLengthIndices(library, fn)) indices.add(index);
+    return indices;
+};
+
+export const parameterIdentifier = (parameter: GirParameter, index: number): string => {
+    if (parameter.name.length === 0) return `arg${index}`;
+    return toCamelIdentifier(parameter.name);
+};
+
+export const renderHandlerParameters = (
+    parameters: GirParameter[],
+    renderType: (ref: TypeId | undefined, nullable: boolean) => string,
+    additionalExclude: (parameter: GirParameter) => boolean = () => false,
+): string[] =>
+    parameters
+        .filter((parameter) => !parameter.isVarargs && !isOutParameter(parameter) && !additionalExclude(parameter))
+        .map(
+            (parameter, index) =>
+                `${parameterIdentifier(parameter, index)}: ${renderType(parameter.type, parameter.nullable)}`,
+        );
+
+export const foldOutParamShape = (primary: string | undefined, outTypes: string[]): string => {
+    if (primary !== undefined) return `[${primary}, ${outTypes.join(", ")}]`;
+    const [single, ...rest] = outTypes;
+    if (rest.length === 0 && single !== undefined) return single;
+    return `[${outTypes.join(", ")}]`;
+};
+
+type HandlerResultOptions = {
+    library: Library;
+    signal: GirSignal;
+    renderType: (ref: TypeId | undefined, nullable: boolean) => string;
+    includeCallerAllocated: boolean;
+    optOut: boolean;
+};
+
+export const renderHandlerResultType = (options: HandlerResultOptions): string => {
+    const { library, signal, renderType, includeCallerAllocated, optOut } = options;
+    const primary = omitsPrimaryReturn(library, signal.returnValue)
+        ? undefined
+        : renderType(signal.returnValue.type, signal.returnValue.nullable);
+    const outTypes = signal.parameters
+        .filter(
+            (parameter) =>
+                !parameter.isVarargs &&
+                (isOutParameter(parameter) ||
+                    isCellInout(library, parameter) ||
+                    (includeCallerAllocated && isCallerAllocatedOut(parameter))),
+        )
+        .map((parameter) => renderType(parameter.type, false));
+    if (outTypes.length === 0) {
+        if (primary === undefined) return "void";
+        return optOut ? `${primary} | undefined` : primary;
+    }
+    return foldOutParamShape(primary, outTypes);
+};

package/src/analysis/ts-type.ts

@@ -0,0 +1,88 @@
+import type { Library } from "../gir/library.js";
+import { PRIMITIVE_TS_TYPE } from "../gir/primitives.js";
+import type { EntityType, GirType } from "../gir/type.js";
+import type { TypeId } from "../gir/type-id.js";
+import { isClassStructRecord } from "../store/gi/class-struct-record.js";
+import { gtypeTsType } from "../store/gi/gtype-binding.js";
+import type { ModuleContext } from "../writer/context.js";
+
+type ReferenceName = {
+    namespaceName: string;
+    typeName: string;
+};
+
+export type TsTypeTarget = {
+    containerStyle: "map" | "record";
+    callbackType: string;
+    byteArrayAsNumber: boolean;
+    renderNamed: (resolved: GirType | undefined, name: ReferenceName) => string;
+    renderGtype: () => string;
+};
+
+const willEmitEntity = (library: Library, type: EntityType): boolean => {
+    switch (type.kind) {
+        case "callback":
+            return type.value.introspectable && type.value.name.length > 0;
+        case "record":
+            return (
+                type.value.introspectable &&
+                !type.value.isVtable &&
+                type.value.name.length > 0 &&
+                !isClassStructRecord(library, type.namespace.name, type.value)
+            );
+        default:
+            return true;
+    }
+};
+
+export const renderBaseTypeFor = (library: Library, target: TsTypeTarget, ref: TypeId | undefined): string => {
+    if (ref === undefined) return "void";
+    const type = library.typeOf(ref);
+    const name = library.nameOf(ref);
+    if (type === undefined) return renderNamedType(target, undefined, name);
+    switch (type.kind) {
+        case "primitive":
+            return type.category === "gtype" ? target.renderGtype() : PRIMITIVE_TS_TYPE[type.category];
+        case "varargs":
+            return "unknown[]";
+        case "callback":
+        case "class":
+        case "interface":
+        case "record":
+        case "enum":
+        case "alias":
+            return renderNamedType(target, type, willEmitEntity(library, type) ? name : undefined);
+        case "carray":
+            return `${renderBaseTypeFor(library, target, type.element)}[]`;
+        case "list":
+            if (type.flavor === "gbytearray" && target.byteArrayAsNumber) return "number[]";
+            return `${renderBaseTypeFor(library, target, type.element)}[]`;
+        case "hashtable": {
+            const key = renderBaseTypeFor(library, target, type.key);
+            const value = renderBaseTypeFor(library, target, type.value);
+            return target.containerStyle === "record" ? `Record<${key}, ${value}>` : `Map<${key}, ${value}>`;
+        }
+    }
+};
+
+const renderNamedType = (
+    target: TsTypeTarget,
+    resolved: GirType | undefined,
+    name: ReferenceName | undefined,
+): string => {
+    if (name === undefined) return resolved?.kind === "callback" ? target.callbackType : "unknown";
+    return target.renderNamed(resolved, name);
+};
+
+const moduleTarget = (context: ModuleContext): TsTypeTarget => ({
+    containerStyle: "map",
+    callbackType: "((...args: any[]) => any)",
+    byteArrayAsNumber: true,
+    renderNamed: (_resolved, name) => context.qualify(name.namespaceName, name.typeName),
+    renderGtype: () => gtypeTsType(context),
+});
+
+export const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
+    const base = renderBaseTypeFor(context.library, moduleTarget(context), ref);
+    return isNullable ? `${base} | null` : base;
+};

package/src/compile.ts

@@ -0,0 +1,152 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+const require = createRequire(import.meta.url);
+
+export type SourceModule = {
+    fileName: string;
+    source: string;
+};
+
+export type CompileProjectParams = {
+    projectDir: string;
+    fileNames: string[];
+    compilerOptions: Record<string, unknown>;
+    label: string;
+    paths?: Record<string, string[]>;
+};
+
+const BASE_COMPILER_OPTIONS = {
+    module: "esnext",
+    moduleResolution: "bundler",
+    target: "esnext",
+    lib: ["esnext"],
+    jsx: "react-jsx",
+    jsxImportSource: "react",
+    customConditions: ["source"],
+    strict: true,
+    exactOptionalPropertyTypes: true,
+    noUncheckedIndexedAccess: true,
+    noImplicitReturns: true,
+    noFallthroughCasesInSwitch: true,
+    allowUnreachableCode: false,
+    forceConsistentCasingInFileNames: true,
+    resolveJsonModule: true,
+    skipLibCheck: true,
+    types: ["node"],
+};
+
+const codegenModules = (): string => dirname(dirname(dirname(require.resolve("@types/node/package.json"))));
+
+const linkToolingModules = (projectDir: string): (() => void) => {
+    const link = join(projectDir, "node_modules");
+    if (existsSync(link)) return () => {};
+    symlinkSync(codegenModules(), link, "junction");
+    return () => rmSync(link, { force: true });
+};
+
+const tscBin = (): string => join(dirname(require.resolve("typescript/package.json")), "bin", "tsc");
+
+const runTsc = (tsconfigPath: string, cwd: string): { code: number; output: string } => {
+    try {
+        execFileSync(process.execPath, [tscBin(), "--pretty", "false", "-p", tsconfigPath], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        return { code: 0, output: "" };
+    } catch (error) {
+        const {
+            status,
+            stdout = "",
+            stderr = "",
+        } = error as { status?: number | null; stdout?: string; stderr?: string };
+        return { code: typeof status === "number" ? status : 1, output: `${stdout}\n${stderr}` };
+    }
+};
+
+const DIAGNOSTIC_LINE = /^(.+?)\((\d+),(\d+)\): error TS(\d+): (.*)$/;
+
+type ProjectDiagnostic = { file: string; line: string; column: string; code: string; message: string };
+
+const parseDiagnostics = (output: string, projectDir: string): ProjectDiagnostic[] => {
+    const diagnostics: ProjectDiagnostic[] = [];
+    for (const raw of output.split(/\r?\n/)) {
+        const match = DIAGNOSTIC_LINE.exec(raw);
+        if (match === null) continue;
+        const [, filePart, line, column, code, message] = match;
+        if (filePart === undefined || line === undefined || column === undefined || code === undefined) continue;
+        const file = resolve(projectDir, filePart);
+        const rel = relative(projectDir, file);
+        if (rel.startsWith("..") || isAbsolute(rel) || rel.split(/[/\\]/).includes("node_modules")) continue;
+        diagnostics.push({ file, line, column, code, message: (message ?? "").trim() });
+    }
+    return diagnostics;
+};
+
+const formatDiagnostics = (label: string, projectDir: string, diagnostics: ProjectDiagnostic[]): string => {
+    const messages = diagnostics.map(
+        (diagnostic) =>
+            `${relative(projectDir, diagnostic.file)}:${diagnostic.line}:${diagnostic.column} - ${diagnostic.message} (TS${diagnostic.code})`,
+    );
+    return `Type checking ${label} found ${diagnostics.length} error(s):\n${messages.join("\n")}`;
+};
+
+export const compileProject = (params: CompileProjectParams): void => {
+    const tsconfigPath = join(params.projectDir, "tsconfig.json");
+    const unlinkToolingModules = linkToolingModules(params.projectDir);
+    try {
+        writeFileSync(
+            tsconfigPath,
+            JSON.stringify({
+                compilerOptions: {
+                    ...BASE_COMPILER_OPTIONS,
+                    ...params.compilerOptions,
+                    ...(params.paths === undefined ? {} : { paths: params.paths }),
+                },
+                files: params.fileNames.map((name) => `./${name}`),
+            }),
+        );
+        const { code, output } = runTsc(tsconfigPath, params.projectDir);
+        const diagnostics = parseDiagnostics(output, params.projectDir);
+        if (diagnostics.length > 0) {
+            throw new Error(formatDiagnostics(params.label, params.projectDir, diagnostics));
+        }
+        if (code !== 0) {
+            throw new Error(`Type checking ${params.label} failed:\n${output.trim()}`);
+        }
+    } finally {
+        unlinkToolingModules();
+        rmSync(tsconfigPath, { force: true });
+    }
+};
+
+const CHECK_OPTIONS = {
+    declaration: true,
+    isolatedDeclarations: true,
+    noEmit: true,
+};
+
+export const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; label: string }): void => {
+    const checkRoot = join(params.resolveFrom, "node_modules");
+    mkdirSync(checkRoot, { recursive: true });
+    const projectDir = mkdtempSync(join(checkRoot, ".gtkx-check-"));
+    try {
+        for (const module of params.modules) {
+            const filePath = join(projectDir, module.fileName);
+            mkdirSync(dirname(filePath), { recursive: true });
+            writeFileSync(filePath, module.source);
+        }
+        compileProject({
+            projectDir,
+            fileNames: params.modules.map((module) => module.fileName),
+            compilerOptions: CHECK_OPTIONS,
+            label: params.label,
+        });
+    } finally {
+        rmSync(projectDir, { recursive: true, force: true });
+    }
+};