@ts-type/object-freeze 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.0.6](https://github.com/bluelovers/ws-ts-type/compare/@ts-type/object-freeze@1.0.5...@ts-type/object-freeze@1.0.6) (2026-03-07)
+
+**Note:** Version bump only for package @ts-type/object-freeze
+
+
+
+
+
+## [1.0.5](https://github.com/bluelovers/ws-ts-type/compare/@ts-type/object-freeze@1.0.4...@ts-type/object-freeze@1.0.5) (2026-03-07)
+
+
+
+### 📚　Documentation
+
+* enhance documentation and JSDoc comments across multiple packages ([88ee99b](https://github.com/bluelovers/ws-ts-type/commit/88ee99b3a489645ca53093357cc3523dbe7996e0))
+
+
+### 🛠　Build System
+
+* 更新多個套件的 test 指令為 jest ([61ea53b](https://github.com/bluelovers/ws-ts-type/commit/61ea53bf15fc3ed0e216793200604ae5a52079c9))
+
+
+### ♻️　Chores
+
+* migrate from yarn to pnpm and enhance test infrastructure ([8a5daa2](https://github.com/bluelovers/ws-ts-type/commit/8a5daa2f2022eaf025c3349d4fe5dc8971f8c077))
+
+
+
 ## [1.0.4](https://github.com/bluelovers/ws-ts-type/compare/@ts-type/object-freeze@1.0.3...@ts-type/object-freeze@1.0.4) (2022-10-10)
 
 

package/README.md

@@ -1,8 +1,19 @@
-# README.md
+# @ts-type/object-freeze
 
-    
+Object.freeze 的類型安全包裝，提供精確的唯讀類型
 
-## install
+Type-safe wrapper for Object.freeze with precise readonly types
+
+## 功能特點 / Features
+
+- 凍結陣列並回傳唯讀類型
+- Freeze array and return readonly type
+- 凍結物件並回傳唯讀類型
+- Freeze object and return readonly type
+- 支援函式、陣列、元組等多種類型
+- Support function, array, tuple and more types
+
+## 安裝 / Install
 
 ```bash
 yarn add @ts-type/object-freeze
@@ -10,3 +21,19 @@ yarn-tool add @ts-type/object-freeze
 yt add @ts-type/object-freeze
 ```
 
+## 使用範例 / Usage Example
+
+```typescript
+import { freezeArray, freezeObject } from '@ts-type/object-freeze';
+
+// 凍結陣列
+const arr = [1, 2, 3];
+const frozenArr = freezeArray(arr);
+// TypeScript 知道 frozenArr 是唯讀陣列
+
+// 凍結物件
+const obj = { name: 'John', age: 30 };
+const frozenObj = freezeObject(obj);
+// TypeScript 知道 frozenObj 是 Readonly<{name: string, age: number}>
+```
+

package/dist/index.cjs

@@ -1,8 +1,8 @@
 
 'use strict'
 
-if (typeof process !== 'undefined' && process.env.NODE_ENV === 'production') {
-  module.exports = require('./index.cjs.production.min.cjs')
-} else {
+if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') {
   module.exports = require('./index.cjs.development.cjs')
+} else {
+  module.exports = require('./index.cjs.production.min.cjs')
 }

package/dist/index.cjs.development.cjs

@@ -5,11 +5,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function freezeArray(obj) {
   return Object.freeze(obj);
 }
+/**
+ * 凍結物件並回傳唯讀類型（通用實現）
+ * Freeze object and return readonly type (generic implementation)
+ *
+ * 使用 Object.freeze 凍結物件，使其不可變
+ * Uses Object.freeze to freeze the object to make it immutable
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 凍結後的物件 / Frozen object
+ */
 function freezeObject(obj) {
   return Object.freeze(obj);
 }
 
-exports["default"] = freezeObject;
+exports.default = freezeObject;
 exports.freezeArray = freezeArray;
 exports.freezeObject = freezeObject;
 //# sourceMappingURL=index.cjs.development.cjs.map

package/dist/index.cjs.development.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":["obj"],"mappings":";;;;;;;qBAuBA,CAA2BA,GAA3B,EAA2B;;;;;;;;"}
+{"version":3,"file":"index.cjs.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":[],"mappings":";;;;;;AAsEA,CAAA;;AAAA;;AAKA;;;;;;;;;;;;;;;"}

package/dist/index.cjs.production.min.cjs

@@ -1,2 +1,12 @@
-"use strict";function freezeObject(e){return Object.freeze(e)}Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=freezeObject,exports.freezeArray=function freezeArray(e){return Object.freeze(e)},exports.freezeObject=freezeObject;
+"use strict";
+
+function freezeObject(e) {
+  return Object.freeze(e);
+}
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.default = freezeObject, exports.freezeArray = function freezeArray(e) {
+  return Object.freeze(e);
+}, exports.freezeObject = freezeObject;
 //# sourceMappingURL=index.cjs.production.min.cjs.map

package/dist/index.cjs.production.min.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs.production.min.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":["obj"],"mappings":"mCAuB2BA"}
+{"version":3,"file":"index.cjs.production.min.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":[],"mappings":";;;;;;;;;;AAsEA"}

package/dist/index.d.ts

@@ -1,13 +1,55 @@
 import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';
 import { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';
 import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';
+/**
+ * 凍結陣列並回傳唯讀類型
+ * Freeze array and return readonly type
+ *
+ * @param obj - 要凍結的陣列 / Array to freeze
+ * @returns 唯讀陣列類型 / Readonly array type
+ */
 export declare function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>;
 export declare function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>;
+/**
+ * 凍結物件並回傳唯讀類型（空元組版本）
+ * Freeze object and return readonly type (empty tuple version)
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export declare function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>;
+/**
+ * 凍結物件並回傳唯讀類型（陣列版本）
+ * Freeze object and return readonly type (array version)
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 唯讀陣列類型 / Readonly array type
+ */
 export declare function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>;
+/**
+ * 凍結函式並保持原類型
+ * Freeze function and preserve original type
+ *
+ * @param f - 要凍結的函式 / Function to freeze
+ * @returns 凍結後的函式 / Frozen function
+ */
 export declare function freezeObject<T extends Function>(f: T): T;
+/**
+ * 凍結物件並回傳唯讀類型（鍵值物件版本）
+ * Freeze object and return readonly type (key-value object version)
+ *
+ * @param o - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export declare function freezeObject<T extends {
     [idx: string]: U | null | undefined | object;
 }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+/**
+ * 凍結物件並回傳唯讀類型（通用版本）
+ * Freeze object and return readonly type (generic version)
+ *
+ * @param o - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export declare function freezeObject<T>(o: T): Readonly<T>;
 export default freezeObject;

package/dist/index.esm.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.mjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":["obj"],"mappings":";;;;sBAuB2BA;;;;"}
+{"version":3,"file":"index.esm.mjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":[],"mappings":";;AAsEA;;;;;;"}

package/dist/index.umd.development.cjs

@@ -7,11 +7,21 @@
 	function freezeArray(obj) {
 	  return Object.freeze(obj);
 	}
+	/**
+	 * 凍結物件並回傳唯讀類型（通用實現）
+	 * Freeze object and return readonly type (generic implementation)
+	 *
+	 * 使用 Object.freeze 凍結物件，使其不可變
+	 * Uses Object.freeze to freeze the object to make it immutable
+	 *
+	 * @param obj - 要凍結的物件 / Object to freeze
+	 * @returns 凍結後的物件 / Frozen object
+	 */
 	function freezeObject(obj) {
 	  return Object.freeze(obj);
 	}
 
-	exports["default"] = freezeObject;
+	exports.default = freezeObject;
 	exports.freezeArray = freezeArray;
 	exports.freezeObject = freezeObject;
 

package/dist/index.umd.development.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":["obj"],"mappings":";;;;;;;;;sBAuBA,CAA2BA,GAA3B,EAA2B;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.umd.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":[],"mappings":";;;;;;;;CAsEA,CAAA;;CAAA;;CAKA;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.umd.production.min.cjs

@@ -1,2 +1,14 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).TsTypeObjectFreeze={})}(this,(function(e){"use strict";function freezeObject(e){return Object.freeze(e)}e.default=freezeObject,e.freezeArray=function freezeArray(e){return Object.freeze(e)},e.freezeObject=freezeObject,Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e, t) {
+  "object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define([ "exports" ], t) : t((e = "undefined" != typeof globalThis ? globalThis : e || self).TsTypeObjectFreeze = {});
+}(this, function(e) {
+  "use strict";
+  function freezeObject(e) {
+    return Object.freeze(e);
+  }
+  e.default = freezeObject, e.freezeArray = function freezeArray(e) {
+    return Object.freeze(e);
+  }, e.freezeObject = freezeObject, Object.defineProperty(e, "__esModule", {
+    value: !0
+  });
+});
 //# sourceMappingURL=index.umd.production.min.cjs.map

package/dist/index.umd.production.min.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.production.min.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":["obj"],"mappings":"gRAuB2BA"}
+{"version":3,"file":"index.umd.production.min.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"],"names":[],"mappings":";;;;;;;;;AAsEA;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ts-type/object-freeze",
-  "version": "1.0.4",
-  "description": "better typescript type for Object.freeze",
+  "version": "1.0.6",
+  "description": "Object.freeze 的類型安全包裝，提供精確的唯讀類型 | Type-safe wrapper for Object.freeze with precise readonly types",
   "keywords": [
     ".d.ts",
     "@types",
@@ -44,8 +44,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.esm.mjs",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.esm.mjs"
     },
     "./package.json": "./package.json",
     "./src/*": "./src/*"
@@ -63,13 +63,14 @@
     "lint": "yarn run lint:eslint",
     "lint:eslint": "ynpx eslint --ext .ts,.tsx,.mts,.cts ./",
     "pretest": "echo pretest",
-    "test": "echo \"Error: no test specified\"",
+    "test": "jest --passWithNoTests",
     "test:jest": "jest --passWithNoTests",
+    "test:jest:coverage": "node --run test:jest -- --coverage",
     "test:jest:snapshot": "yarn run test:jest -- -u",
     "test:mocha": "ynpx --quiet -p ts-node -p mocha mocha -- --require ts-node/register \"!(node_modules)/**/*.{test,spec}.{ts,tsx}\"",
     "test:snapshot": "yarn run test -- -u",
     "test:tsd": "ynpx tsd",
-    "test:tsdx": "ynpx @bluelovers/tsdx test --passWithNoTests",
+    "test:tsdx": "tsdx test --passWithNoTests",
     "posttest": "yarn run build",
     "build": "yarn run build:tsdx && yarn run build:dts:tsc",
     "build:dts:bundle": "ynpx dts-bundle-generator -o ./dist/index.d.ts ./src/index.ts --no-banner --inline-declare-global & echo build:dts:bundle",
@@ -77,7 +78,7 @@
     "build:dts:tsc": "yarn run build:dts:tsc:emit && yarn run build:dts:copy",
     "build:dts:tsc:emit": "tsc --emitDeclarationOnly --declaration --noEmit false",
     "build:microbundle": "ynpx microbundle --target node",
-    "build:tsdx": "ynpx @bluelovers/tsdx build --target node --name index",
+    "build:tsdx": "tsdx build --target node --name index",
     "ci:install": "echo ci:install",
     "ci:build": "echo ci:build",
     "preversion": "echo preversion && yarn run test",
@@ -98,11 +99,10 @@
     "tsc:showConfig": "ynpx get-current-tsconfig -p"
   },
   "dependencies": {
-    "ts-type": "^3.0.1"
+    "ts-type": "^3.0.3"
   },
-  "packageManager": "yarn@^1.22.11",
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fa34eea119b9bcbb363061ddffcfe9d78c2d0ddd"
+  "gitHead": "4ef633a04245358fed59633c9d9ceff0607d30d3"
 }

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAMA,SAAgB,WAAW,CAA+C,GAAM;IAE/E,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAHD,kCAGC;AASD,SAAgB,YAAY,CAA+C,GAAM;IAEhF,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAHD,oCAGC;AAED,kBAAe,YAAY,CAAA","sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\nexport function freezeObject<T extends Function>(f: T): T\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\nexport function freezeObject<T>(o: T): Readonly<T>\n\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;AAaA,kCAGC;AAsDD,oCAGC;AA5DD,SAAgB,WAAW,CAA+C,GAAM;IAE/E,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AA4CD;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAA+C,GAAM;IAEhF,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAED,kBAAe,YAAY,CAAA","sourcesContent":["import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';\nimport { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';\nimport { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\n\n/**\n * 凍結陣列並回傳唯讀類型\n * Freeze array and return readonly type\n *\n * @param obj - 要凍結的陣列 / Array to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\nexport function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\n/**\n * 凍結物件並回傳唯讀類型（空元組版本）\n * Freeze object and return readonly type (empty tuple version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>\n/**\n * 凍結物件並回傳唯讀類型（陣列版本）\n * Freeze object and return readonly type (array version)\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 唯讀陣列類型 / Readonly array type\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>\n\n/**\n * 凍結函式並保持原類型\n * Freeze function and preserve original type\n *\n * @param f - 要凍結的函式 / Function to freeze\n * @returns 凍結後的函式 / Frozen function\n */\nexport function freezeObject<T extends Function>(f: T): T\n/**\n * 凍結物件並回傳唯讀類型（鍵值物件版本）\n * Freeze object and return readonly type (key-value object version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>\n/**\n * 凍結物件並回傳唯讀類型（通用版本）\n * Freeze object and return readonly type (generic version)\n *\n * @param o - 要凍結的物件 / Object to freeze\n * @returns 唯讀物件類型 / Readonly object type\n */\nexport function freezeObject<T>(o: T): Readonly<T>\n\n/**\n * 凍結物件並回傳唯讀類型（通用實現）\n * Freeze object and return readonly type (generic implementation)\n *\n * 使用 Object.freeze 凍結物件，使其不可變\n * Uses Object.freeze to freeze the object to make it immutable\n *\n * @param obj - 要凍結的物件 / Object to freeze\n * @returns 凍結後的物件 / Frozen object\n */\nexport function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)\n{\n\treturn Object.freeze(obj)\n}\n\nexport default freezeObject\n"]}

package/src/index.ts

@@ -2,6 +2,13 @@ import { ITSEmptyTuple } from 'ts-type/lib/type/tuple/empty';
 import { ITSToReadonlyArray } from 'ts-type/lib/helper/array/readonly';
 import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';
 
+/**
+ * 凍結陣列並回傳唯讀類型
+ * Freeze array and return readonly type
+ *
+ * @param obj - 要凍結的陣列 / Array to freeze
+ * @returns 唯讀陣列類型 / Readonly array type
+ */
 export function freezeArray<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>
 export function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>
 export function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)
@@ -9,13 +16,58 @@ export function freezeArray<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T
 	return Object.freeze(obj)
 }
 
+/**
+ * 凍結物件並回傳唯讀類型（空元組版本）
+ * Freeze object and return readonly type (empty tuple version)
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export function freezeObject<T extends ITSEmptyTuple>(obj: T): ITSToReadonlyArray<T>
+/**
+ * 凍結物件並回傳唯讀類型（陣列版本）
+ * Freeze object and return readonly type (array version)
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 唯讀陣列類型 / Readonly array type
+ */
 export function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T): ITSToReadonlyArray<T>
 
+/**
+ * 凍結函式並保持原類型
+ * Freeze function and preserve original type
+ *
+ * @param f - 要凍結的函式 / Function to freeze
+ * @returns 凍結後的函式 / Frozen function
+ */
 export function freezeObject<T extends Function>(f: T): T
+/**
+ * 凍結物件並回傳唯讀類型（鍵值物件版本）
+ * Freeze object and return readonly type (key-value object version)
+ *
+ * @param o - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export function freezeObject<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>
+/**
+ * 凍結物件並回傳唯讀類型（通用版本）
+ * Freeze object and return readonly type (generic version)
+ *
+ * @param o - 要凍結的物件 / Object to freeze
+ * @returns 唯讀物件類型 / Readonly object type
+ */
 export function freezeObject<T>(o: T): Readonly<T>
 
+/**
+ * 凍結物件並回傳唯讀類型（通用實現）
+ * Freeze object and return readonly type (generic implementation)
+ *
+ * 使用 Object.freeze 凍結物件，使其不可變
+ * Uses Object.freeze to freeze the object to make it immutable
+ *
+ * @param obj - 要凍結的物件 / Object to freeze
+ * @returns 凍結後的物件 / Frozen object
+ */
 export function freezeObject<T extends ITSArrayListMaybeReadonly<unknown>>(obj: T)
 {
 	return Object.freeze(obj)