@ddd-ts/freeze 0.0.0-freeze-hint-function.2 → 0.0.0-improve-freeze-function-stability.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Aetherall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/entrypoints/freeze-decorator.entrypoint.js

@@ -1,101 +1,114 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts_morph_1 = require("ts-morph");
-const node_path_1 = require("node:path");
-const explore_type_1 = require("../utils/explore-type");
-const node_fs_1 = __importDefault(require("node:fs"));
-const project_1 = require("./project");
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_explore_type = require('../utils/explore-type.js');
+const require_project = require('./project.js');
+const require_package = require('../package.js');
+let ts_morph = require("ts-morph");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+
+//#region src/entrypoints/freeze-decorator.entrypoint.ts
 const cwd = process.cwd();
-const decoratorFile = project_1.project.getSourceFile(`${__dirname}/../references/freeze.decorator.d.ts`);
-if (!decoratorFile) {
-    throw new Error("The @Freeze decorator is not used in the project.");
-}
-const references = decoratorFile.getFunction("Freeze")?.findReferences();
-if (!references) {
-    throw new Error("The @Freeze decorator is imported, but not used in the project.");
+const resolveFromDistIndex = () => {
+	const decoratorFilePath = `${__dirname}/../../dist/index.d.ts`;
+	const decoratorFile = require_project.project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find index.d.ts at path ${decoratorFilePath}`);
+	const decoratorFunction = decoratorFile.getExportedDeclarations().get("Freeze")?.[0].asKind(ts_morph.ts.SyntaxKind.FunctionDeclaration);
+	if (!decoratorFunction) throw new Error(`Cannot find function for Freeze decorator in ${decoratorFilePath}`);
+	const references = decoratorFunction.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+const resolveFromDist = () => {
+	const decoratorFilePath = `${__dirname}/../references/freeze.decorator.d.ts`;
+	const decoratorFile = require_project.project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find freeze.decorator.d.ts at path ${decoratorFilePath}`);
+	const references = decoratorFile.getFunction("Freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+const resolveFromSource = () => {
+	const decoratorFilePath = `${__dirname}/../references/freeze.decorator.ts`;
+	const decoratorFile = require_project.project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find freeze.decorator.ts at path ${decoratorFilePath}`);
+	const references = decoratorFile.getFunction("Freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+let references;
+try {
+	references = resolveFromDistIndex();
+} catch (e) {
+	try {
+		references = resolveFromDist();
+	} catch (e) {
+		try {
+			references = resolveFromSource();
+		} catch (e) {
+			throw new Error("Cannot find declaration of the Freeze decorator in dist/index.d.ts, dist/references/freeze.decorator.d.ts or src/references/freeze.decorator.ts");
+		}
+	}
 }
 function lowercasefirstletter(str) {
-    return str.charAt(0).toLowerCase() + str.slice(1);
+	return str.charAt(0).toLowerCase() + str.slice(1);
 }
-for (const ref of references) {
-    for (const refref of ref.getReferences()) {
-        const decorator = refref
-            .getNode()
-            .getParent()
-            ?.getParent()
-            ?.asKind(ts_morph_1.ts.SyntaxKind.Decorator);
-        if (!decorator)
-            continue;
-        const rpath = (0, node_path_1.relative)(cwd, decorator.getSourceFile().getFilePath());
-        const classDeclaration = decorator.getParentIfKind(ts_morph_1.ts.SyntaxKind.ClassDeclaration);
-        if (!classDeclaration)
-            continue;
-        const typeParameter = decorator.getTypeArguments()[0];
-        if (typeParameter) {
-            console.log(`${classDeclaration.getName()}: Already frozen with <${typeParameter.getText()}>`);
-            continue;
-        }
-        const serializeProperty = classDeclaration
-            .getType()
-            .getProperty("serialize");
-        if (!serializeProperty) {
-            console.log(`${rpath} - ${classDeclaration.getName()}: No serialize property`);
-            continue;
-        }
-        const serializeMethod = project_1.project
-            .getTypeChecker()
-            .getTypeOfSymbolAtLocation(serializeProperty, classDeclaration)
-            .getCallSignatures()[0];
-        let serialized = serializeMethod.getReturnType();
-        if (serialized.getSymbol()?.getName() === "Promise") {
-            serialized = serialized.getTypeArguments()[0];
-        }
-        const version = serialized
-            .getProperty("version")
-            ?.getTypeAtLocation(classDeclaration)
-            .getText();
-        if (!version || Number.isNaN(Number(version))) {
-            console.log(`${rpath} - ${classDeclaration.getName()}: No version property (or not a number) : ${version}`);
-            continue;
-        }
-        console.log(`${rpath} - ${classDeclaration.getName()}: Freezing with version ${version}`);
-        const other = new Map();
-        const result = (0, explore_type_1.exploreType)(serialized.compilerType, project_1.project.getTypeChecker().compilerObject, other);
-        const type = serializeMethod
-            .getParameters()[0]
-            .getTypeAtLocation(classDeclaration);
-        const symbol = type.getSymbol()?.getName();
-        const aliasSymbol = type.getAliasSymbol()?.getName();
-        let name;
-        if (symbol) {
-            name = symbol;
-            console.log(`${rpath} - ${classDeclaration.getName()}: Using symbol ${symbol}`);
-        }
-        else if (aliasSymbol) {
-            name = aliasSymbol;
-            console.log(`${rpath} - ${classDeclaration.getName()}: Using aliasSymbol ${aliasSymbol}`);
-        }
-        if (!name) {
-            console.log(`${rpath} - ${classDeclaration.getName()}: Cannot find name of serialized type`);
-            continue;
-        }
-        const serializedName = `${name}Serialized${version}n`;
-        const serializedFilename = lowercasefirstletter(`${name}.serialized.${version}n`);
-        const directory = refref.getSourceFile().getDirectory();
-        decorator.getSourceFile().addImportDeclaration({
-            moduleSpecifier: `./${serializedFilename}`,
-            namedImports: [serializedName],
-        });
-        decorator.addTypeArgument(serializedName);
-        project_1.project.saveSync();
-        const output = [
-            ...other.values(),
-            `export type ${serializedName} = ${result}`,
-        ].join("\n");
-        node_fs_1.default.writeFileSync(`${directory.getPath()}/${serializedFilename}.ts`, output);
-    }
+for (const ref of references) for (const refref of ref.getReferences()) {
+	const decorator = refref.getNode().getParent()?.getParent()?.asKind(ts_morph.ts.SyntaxKind.Decorator);
+	if (!decorator) continue;
+	const rpath = (0, node_path.relative)(cwd, decorator.getSourceFile().getFilePath());
+	const classDeclaration = decorator.getParentIfKind(ts_morph.ts.SyntaxKind.ClassDeclaration);
+	if (!classDeclaration) continue;
+	const typeParameter = decorator.getTypeArguments()[0];
+	if (typeParameter) {
+		console.log(`${classDeclaration.getName()}: Already frozen with <${typeParameter.getText()}>`);
+		continue;
+	}
+	const serializeProperty = classDeclaration.getType().getProperty("serialize");
+	if (!serializeProperty) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: No serialize property`);
+		continue;
+	}
+	const serializeMethod = require_project.project.getTypeChecker().getTypeOfSymbolAtLocation(serializeProperty, classDeclaration).getCallSignatures()[0];
+	let serialized = serializeMethod.getReturnType();
+	if (serialized.getSymbol()?.getName() === "Promise") serialized = serialized.getTypeArguments()[0];
+	const version = serialized.getProperty("version")?.getTypeAtLocation(classDeclaration).getText();
+	if (!version || Number.isNaN(Number(version))) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: No version property (or not a number) : ${version}`);
+		continue;
+	}
+	console.log(`${rpath} - ${classDeclaration.getName()}: Freezing with version ${version}`);
+	const other = /* @__PURE__ */ new Map();
+	const result = require_explore_type.exploreType(serialized.compilerType, require_project.project.getTypeChecker().compilerObject, other);
+	const type = serializeMethod.getParameters()[0].getTypeAtLocation(classDeclaration);
+	const symbol = type.getSymbol()?.getName();
+	const aliasSymbol = type.getAliasSymbol()?.getName();
+	let name$1;
+	if (symbol) {
+		name$1 = symbol;
+		console.log(`${rpath} - ${classDeclaration.getName()}: Using symbol ${symbol}`);
+	} else if (aliasSymbol) {
+		name$1 = aliasSymbol;
+		console.log(`${rpath} - ${classDeclaration.getName()}: Using aliasSymbol ${aliasSymbol}`);
+	}
+	if (!name$1) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: Cannot find name of serialized type`);
+		continue;
+	}
+	const serializedName = `${name$1}Serialized${version}n`;
+	const serializedFilename = lowercasefirstletter(`${name$1}.serialized.${version}n`);
+	const directory = refref.getSourceFile().getDirectory();
+	decorator.getSourceFile().addImportDeclaration({
+		moduleSpecifier: `./${serializedFilename}`,
+		namedImports: [serializedName]
+	});
+	decorator.addTypeArgument(serializedName);
+	require_project.project.saveSync();
+	const output = [
+		`// Auto-generated by ${require_package.name}`,
+		...other.values(),
+		`export type ${serializedName} = ${result}`
+	].join("\n");
+	node_fs.default.writeFileSync(`${directory.getPath()}/${serializedFilename}.ts`, output);
 }
-//# sourceMappingURL=freeze-decorator.entrypoint.js.map
+
+//#endregion

package/dist/entrypoints/freeze-decorator.entrypoint.mjs

@@ -0,0 +1,113 @@
+import { exploreType } from "../utils/explore-type.mjs";
+import { project } from "./project.mjs";
+import { name } from "../package.mjs";
+import { ts } from "ts-morph";
+import { relative } from "node:path";
+import fs from "node:fs";
+
+//#region src/entrypoints/freeze-decorator.entrypoint.ts
+const cwd = process.cwd();
+const resolveFromDistIndex = () => {
+	const decoratorFilePath = `${__dirname}/../../dist/index.d.ts`;
+	const decoratorFile = project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find index.d.ts at path ${decoratorFilePath}`);
+	const decoratorFunction = decoratorFile.getExportedDeclarations().get("Freeze")?.[0].asKind(ts.SyntaxKind.FunctionDeclaration);
+	if (!decoratorFunction) throw new Error(`Cannot find function for Freeze decorator in ${decoratorFilePath}`);
+	const references = decoratorFunction.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+const resolveFromDist = () => {
+	const decoratorFilePath = `${__dirname}/../references/freeze.decorator.d.ts`;
+	const decoratorFile = project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find freeze.decorator.d.ts at path ${decoratorFilePath}`);
+	const references = decoratorFile.getFunction("Freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+const resolveFromSource = () => {
+	const decoratorFilePath = `${__dirname}/../references/freeze.decorator.ts`;
+	const decoratorFile = project.getSourceFile(decoratorFilePath);
+	if (!decoratorFile) throw new Error(`Cannot find freeze.decorator.ts at path ${decoratorFilePath}`);
+	const references = decoratorFile.getFunction("Freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the Freeze decorator");
+	return references;
+};
+let references;
+try {
+	references = resolveFromDistIndex();
+} catch (e) {
+	try {
+		references = resolveFromDist();
+	} catch (e) {
+		try {
+			references = resolveFromSource();
+		} catch (e) {
+			throw new Error("Cannot find declaration of the Freeze decorator in dist/index.d.ts, dist/references/freeze.decorator.d.ts or src/references/freeze.decorator.ts");
+		}
+	}
+}
+function lowercasefirstletter(str) {
+	return str.charAt(0).toLowerCase() + str.slice(1);
+}
+for (const ref of references) for (const refref of ref.getReferences()) {
+	const decorator = refref.getNode().getParent()?.getParent()?.asKind(ts.SyntaxKind.Decorator);
+	if (!decorator) continue;
+	const rpath = relative(cwd, decorator.getSourceFile().getFilePath());
+	const classDeclaration = decorator.getParentIfKind(ts.SyntaxKind.ClassDeclaration);
+	if (!classDeclaration) continue;
+	const typeParameter = decorator.getTypeArguments()[0];
+	if (typeParameter) {
+		console.log(`${classDeclaration.getName()}: Already frozen with <${typeParameter.getText()}>`);
+		continue;
+	}
+	const serializeProperty = classDeclaration.getType().getProperty("serialize");
+	if (!serializeProperty) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: No serialize property`);
+		continue;
+	}
+	const serializeMethod = project.getTypeChecker().getTypeOfSymbolAtLocation(serializeProperty, classDeclaration).getCallSignatures()[0];
+	let serialized = serializeMethod.getReturnType();
+	if (serialized.getSymbol()?.getName() === "Promise") serialized = serialized.getTypeArguments()[0];
+	const version = serialized.getProperty("version")?.getTypeAtLocation(classDeclaration).getText();
+	if (!version || Number.isNaN(Number(version))) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: No version property (or not a number) : ${version}`);
+		continue;
+	}
+	console.log(`${rpath} - ${classDeclaration.getName()}: Freezing with version ${version}`);
+	const other = /* @__PURE__ */ new Map();
+	const result = exploreType(serialized.compilerType, project.getTypeChecker().compilerObject, other);
+	const type = serializeMethod.getParameters()[0].getTypeAtLocation(classDeclaration);
+	const symbol = type.getSymbol()?.getName();
+	const aliasSymbol = type.getAliasSymbol()?.getName();
+	let name$1;
+	if (symbol) {
+		name$1 = symbol;
+		console.log(`${rpath} - ${classDeclaration.getName()}: Using symbol ${symbol}`);
+	} else if (aliasSymbol) {
+		name$1 = aliasSymbol;
+		console.log(`${rpath} - ${classDeclaration.getName()}: Using aliasSymbol ${aliasSymbol}`);
+	}
+	if (!name$1) {
+		console.log(`${rpath} - ${classDeclaration.getName()}: Cannot find name of serialized type`);
+		continue;
+	}
+	const serializedName = `${name$1}Serialized${version}n`;
+	const serializedFilename = lowercasefirstletter(`${name$1}.serialized.${version}n`);
+	const directory = refref.getSourceFile().getDirectory();
+	decorator.getSourceFile().addImportDeclaration({
+		moduleSpecifier: `./${serializedFilename}`,
+		namedImports: [serializedName]
+	});
+	decorator.addTypeArgument(serializedName);
+	project.saveSync();
+	const output = [
+		`// Auto-generated by ${name}`,
+		...other.values(),
+		`export type ${serializedName} = ${result}`
+	].join("\n");
+	fs.writeFileSync(`${directory.getPath()}/${serializedFilename}.ts`, output);
+}
+
+//#endregion
+export {  };

package/dist/entrypoints/freeze-function.entrypoint.js

@@ -1,87 +1,119 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts_morph_1 = require("ts-morph");
-const node_path_1 = require("node:path");
-const node_fs_1 = __importDefault(require("node:fs"));
-const explore_type_1 = require("../utils/explore-type");
-const get_pretty_type_1 = require("../utils/get-pretty-type");
-const project_1 = require("./project");
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_explore_type = require('../utils/explore-type.js');
+const require_project = require('./project.js');
+const require_package = require('../package.js');
+const require_get_pretty_type = require('../utils/get-pretty-type.js');
+let ts_morph = require("ts-morph");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let _prettier_sync = require("@prettier/sync");
+_prettier_sync = require_runtime.__toESM(_prettier_sync);
+
+//#region src/entrypoints/freeze-function.entrypoint.ts
 const cwd = process.cwd();
-const functionFile = project_1.project.getSourceFile(`${__dirname}/../references/freeze.function.d.ts`);
-if (!functionFile) {
-    throw new Error("The freeze function is not used in the project.");
-}
-const references = functionFile.getFunction("freeze")?.findReferences();
-if (!references) {
-    throw new Error("The freeze function is imported, but not used in the project.");
+const resolveFromDistIndex = () => {
+	const functionFilePath = `${__dirname}/../../dist/index.d.ts`;
+	const functionFile = require_project.project.getSourceFile(functionFilePath);
+	if (!functionFile) throw new Error(`Cannot find index.d.ts at path ${functionFilePath}`);
+	const freezeFunction = functionFile.getExportedDeclarations().get("freeze")?.[0].asKind(ts_morph.ts.SyntaxKind.FunctionDeclaration);
+	if (!freezeFunction) throw new Error(`Cannot find function for freeze in ${functionFilePath}`);
+	const references = freezeFunction.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the freeze function");
+	return references;
+};
+const resolveFromSource = () => {
+	const functionFilePath = `${__dirname}/../references/freeze.function.ts`;
+	const functionFile = require_project.project.getSourceFile(functionFilePath);
+	if (!functionFile) throw new Error(`Cannot find freeze.function.ts at path ${functionFilePath}`);
+	const references = functionFile.getFunction("freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the freeze function");
+	return references;
+};
+const resolveFromDist = () => {
+	const functionFilePath = `${__dirname}/../references/freeze.function.d.ts`;
+	const functionFile = require_project.project.getSourceFile(functionFilePath);
+	if (!functionFile) throw new Error(`Cannot find freeze.function.d.ts at path ${functionFilePath}`);
+	const references = functionFile.getFunction("freeze")?.findReferences();
+	if (!references) throw new Error("Cannot find declaration of the freeze function");
+	return references;
+};
+let references;
+try {
+	references = resolveFromDistIndex();
+} catch {
+	try {
+		references = resolveFromDist();
+	} catch {
+		try {
+			references = resolveFromSource();
+		} catch {
+			throw new Error("Cannot find references for freeze function in dist/index.d.ts, dist/references/freeze.function.d.ts or src/references/freeze.function.ts");
+		}
+	}
 }
 function lowercasefirstletter(str) {
-    return str.charAt(0).toLowerCase() + str.slice(1);
+	return str.charAt(0).toLowerCase() + str.slice(1);
 }
-for (const ref of references) {
-    for (const refref of ref.getReferences()) {
-        const callExpression = refref
-            .getNode()
-            .getParentIfKind(ts_morph_1.ts.SyntaxKind.CallExpression);
-        if (!callExpression)
-            continue;
-        const rpath = (0, node_path_1.relative)(cwd, callExpression.getSourceFile().getFilePath());
-        const typeArguments = callExpression.getTypeArguments();
-        const freezeParameters = typeArguments[0].asKind(ts_morph_1.ts.SyntaxKind.TypeLiteral);
-        const alreadyFrozen = typeArguments[1];
-        if (!freezeParameters) {
-            console.log(`${rpath}:${callExpression.getStartLineNumber()}: No freeze parameters`);
-            continue;
-        }
-        const nameProperty = freezeParameters.getProperty("name");
-        if (!nameProperty) {
-            console.log(`${rpath}:${callExpression.getStartLineNumber()}: No name property`);
-            continue;
-        }
-        const name = nameProperty.getType().getLiteralValue();
-        if (typeof name !== "string") {
-            console.log(`${rpath}:${callExpression.getStartLineNumber()}: Name is not a string literal`);
-            continue;
-        }
-        if (alreadyFrozen) {
-            console.log(`${rpath} - ${name}: Already frozen with <${alreadyFrozen.getText()}>`);
-            continue;
-        }
-        const typeProperty = freezeParameters.getProperty("type");
-        if (!typeProperty) {
-            console.log(`${rpath} - ${name}: No type property`);
-            continue;
-        }
-        const type = typeProperty.getType();
-        const prettyType = (0, get_pretty_type_1.getPrettyType)(type, callExpression);
-        const other = new Map();
-        let result = (0, explore_type_1.exploreType)(prettyType.type.compilerType, project_1.project.getTypeChecker().compilerObject, other);
-        const aliasName = prettyType.alias.getName();
-        prettyType.dispose();
-        for (const [key, value] of other) {
-            if (key.name !== aliasName)
-                continue;
-            result = result.replace(new RegExp(`\\b${aliasName}\\b`, "g"), value.replace(new RegExp(`^type ${aliasName} = `), ""));
-            other.delete(key);
-        }
-        const serializedName = name;
-        const serializedFilename = lowercasefirstletter(`${name}.serialized`);
-        const directory = refref.getSourceFile().getDirectory();
-        callExpression.getSourceFile().addImportDeclaration({
-            moduleSpecifier: `./${serializedFilename}`,
-            namedImports: [serializedName],
-        });
-        callExpression.addTypeArgument(serializedName);
-        project_1.project.saveSync();
-        const output = [
-            ...other.values(),
-            `export type ${serializedName} = ${result}`,
-        ].join("\n");
-        node_fs_1.default.writeFileSync(`${directory.getPath()}/${serializedFilename}.ts`, output);
-        console.log(`${rpath} - ${name}: Frozen as ${serializedName} in ${serializedFilename}.ts`);
-    }
+for (const ref of references) for (const refref of ref.getReferences()) {
+	const callExpression = refref.getNode().getParentIfKind(ts_morph.ts.SyntaxKind.CallExpression);
+	if (!callExpression) continue;
+	const rpath = (0, node_path.relative)(cwd, callExpression.getSourceFile().getFilePath());
+	const typeArguments = callExpression.getTypeArguments();
+	const freezeParameters = typeArguments[0].asKind(ts_morph.ts.SyntaxKind.TypeLiteral);
+	const alreadyFrozen = typeArguments[1];
+	if (!freezeParameters) {
+		console.log(`${rpath}:${callExpression.getStartLineNumber()}: No freeze parameters`);
+		continue;
+	}
+	const nameProperty = freezeParameters.getProperty("name");
+	if (!nameProperty) {
+		console.log(`${rpath}:${callExpression.getStartLineNumber()}: No name property`);
+		continue;
+	}
+	const name$1 = nameProperty.getType().getLiteralValue();
+	if (typeof name$1 !== "string") {
+		console.log(`${rpath}:${callExpression.getStartLineNumber()}: Name is not a string literal`);
+		continue;
+	}
+	if (alreadyFrozen) {
+		console.log(`${rpath} - ${name$1}: Already frozen with <${alreadyFrozen.getText()}>`);
+		continue;
+	}
+	const typeProperty = freezeParameters.getProperty("type");
+	if (!typeProperty) {
+		console.log(`${rpath} - ${name$1}: No type property`);
+		continue;
+	}
+	const prettyType = require_get_pretty_type.getPrettyType(typeProperty.getType(), callExpression);
+	const other = /* @__PURE__ */ new Map();
+	let result = require_explore_type.exploreType(prettyType.type.compilerType, require_project.project.getTypeChecker().compilerObject, other);
+	const aliasName = prettyType.alias.getName();
+	prettyType.dispose();
+	for (const [key, value] of other) {
+		if (key.name !== aliasName) continue;
+		result = result.replace(new RegExp(`\\b${aliasName}\\b`, "g"), value.replace(new RegExp(`^type ${aliasName} = `), ""));
+		other.delete(key);
+	}
+	const serializedName = name$1;
+	const filenamePropertyValue = freezeParameters.getProperty("filename")?.getType().getLiteralValue();
+	const serializedExtension = freezeParameters.getProperty("extension")?.getType().getLiteralValue() ?? ".serialized";
+	const serializedFilename = filenamePropertyValue ?? lowercasefirstletter(`${serializedName}${serializedExtension}`);
+	const directory = refref.getSourceFile().getDirectory();
+	callExpression.getSourceFile().addImportDeclaration({
+		moduleSpecifier: `./${serializedFilename}`,
+		namedImports: [serializedName]
+	});
+	callExpression.addTypeArgument(serializedName);
+	require_project.project.saveSync();
+	const output = [
+		`// Auto-generated by ${require_package.name}`,
+		...other.values(),
+		`export type ${serializedName} = ${result}`
+	].join("\n");
+	const formattedOutput = _prettier_sync.default.format(output, { parser: "typescript" });
+	node_fs.default.writeFileSync(`${directory.getPath()}/${serializedFilename}.ts`, formattedOutput);
+	console.log(`${rpath} - ${name$1}: Frozen as ${serializedName} in ${serializedFilename}.ts`);
 }
-//# sourceMappingURL=freeze-function.entrypoint.js.map
+
+//#endregion