@ts-type/is-array 1.0.6 → 1.0.7

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.0.7](https://github.com/bluelovers/ws-ts-type/compare/@ts-type/is-array@1.0.6...@ts-type/is-array@1.0.7) (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.6](https://github.com/bluelovers/ws-ts-type/compare/@ts-type/is-array@1.0.5...@ts-type/is-array@1.0.6) (2022-10-10)
 
 

package/README.md

@@ -1,8 +1,19 @@
-# README.md
+# @ts-type/is-array
 
-    
+增強的陣列類型斷言與驗證工具
 
-## install
+Enhanced array type predicates and validation utilities
+
+## 功能特點 / Features
+
+- 擴展 Array.isArray 類型斷言
+- Extend Array.isArray type predicate
+- 支援唯讀陣列與可變陣列類型轉換
+- Support readonly array and writable array type conversion
+- 運行時陣列驗證與斷言
+- Runtime array validation and assertion
+
+## 安裝 / Install
 
 ```bash
 yarn add @ts-type/is-array
@@ -10,3 +21,23 @@ yarn-tool add @ts-type/is-array
 yt add @ts-type/is-array
 ```
 
+## 使用範例 / Usage Example
+
+```typescript
+import { isArray, isArrayPredicates, typePredicatesAsWriteableArray, typePredicatesAsReadonlyArray } from '@ts-type/is-array';
+
+// 使用類型斷言
+function processValue(value: string | string[]) {
+    if (isArray(value)) {
+        // TypeScript 知道 value 是 string[]
+        console.log(value.join(', '));
+    }
+}
+
+// 使用斷言函式（會拋出錯誤）
+function assertArray(arr: unknown) {
+    isArrayPredicates(arr);
+    // 如果通過，arr 被斷言為陣列
+}
+```
+

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

@@ -4,14 +4,44 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assert = require('assert');
 
+/**
+ * 檢查值是否為陣列（類型斷言版本）
+ * Check if value is an array (type predicate version)
+ *
+ * @param arg - 要檢查的值 / Value to check
+ * @returns 是否為輸入類型的類型斷言 / Type predicate of input type
+ */
 function isArray(arg) {
   return Array.isArray(arg);
 }
+/**
+ * 斷言值為可變陣列（不包含 readonly 屬性）
+ * Assert value as writable array (without readonly attribute)
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
+// @ts-ignore
 function typePredicatesAsWriteableArray(value) {}
+/**
+ * 斷言值為唯讀陣列
+ * Assert value as readonly array
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
+// @ts-ignore
 function typePredicatesAsReadonlyArray(value) {}
+/**
+ * 斷言並驗證值為陣列，否則拋出錯誤
+ * Assert and validate that value is an array, otherwise throw error
+ *
+ * @param actual - 要驗證的值 / Value to validate
+ * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)
+ * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array
+ */
 function isArrayPredicates(actual, message) {
   const expression = Array.isArray(actual);
-
   if (!expression) {
     throw new assert.AssertionError({
       message: message !== null && message !== void 0 ? message : `actual ${actual} not as expected`,
@@ -22,7 +52,7 @@ function isArrayPredicates(actual, message) {
   }
 }
 
-exports["default"] = isArray;
+exports.default = isArray;
 exports.isArray = isArray;
 exports.isArrayNarrowed = isArray;
 exports.isArrayPredicates = isArrayPredicates;

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":["typePredicatesAsWriteableArray","value","expression","message"],"mappings":";;;;;;;;AAYA,CAAA;AAuBYA,SAAAA,8BAAT,CAAsDC,KAAtD,EAAsD,EAAA;AAGtD,SAHA,6BAAA,CAAA,KAAA,EAAA,EAAA;;AAKD,EAAA,MAAA,UAAA,GAAA,KAAA,CAAA,OAAA,CAAA,MAAA,CAAA,CAAA;;AACF,EAAA,IAAA,CAACC,UAAD,EAAC;;MAADC;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\n/**\n * 擴展 ArrayConstructor.isArray 方法，支援更精確的類型斷言\n * Extend ArrayConstructor.isArray method for more precise type predicate\n *\n * 允許在運行時檢查值是否為陣列，並在編譯時保留原始陣列類型\n */\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\t/**\n\t\t * 檢查值是否為陣列，並返回類型斷言\n\t\t * Check if value is an array and return type predicate\n\t\t *\n\t\t * @param arg - 要檢查的值 / Value to check\n\t\t * @returns 是否為陣列的類型斷言 / Type predicate indicating if it's an array\n\t\t */\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\n/**\n * 檢查值是否為陣列（類型斷言版本）\n * Check if value is an array (type predicate version)\n *\n * @param arg - 要檢查的值 / Value to check\n * @returns 是否為輸入類型的類型斷言 / Type predicate of input type\n */\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n/**\n * 斷言值為可變陣列（不包含 readonly 屬性）\n * Assert value as writable array (without readonly attribute)\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n/**\n * 斷言值為唯讀陣列\n * Assert value as readonly array\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\n/**\n * 斷言並驗證值為陣列，否則拋出錯誤\n * Assert and validate that value is an array, otherwise throw error\n *\n * @param actual - 要驗證的值 / Value to validate\n * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)\n * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array\n */\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":[],"mappings":";;;;;;;;;AA+EG;;;AAtDH;;;;;;;;;;;;;;;;;;AAsDG;;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,2 +1,24 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("assert");function isArray(r){return Array.isArray(r)}exports.default=isArray,exports.isArray=isArray,exports.isArrayNarrowed=isArray,exports.isArrayPredicates=function isArrayPredicates(e,a){const t=Array.isArray(e);if(!t)throw new r.AssertionError({message:null!=a?a:`actual ${e} not as expected`,actual:e,expected:t,operator:"fail"})},exports.typePredicatesAsReadonlyArray=function typePredicatesAsReadonlyArray(r){},exports.typePredicatesAsWriteableArray=function typePredicatesAsWriteableArray(r){};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+var r = require("assert");
+
+function isArray(r) {
+  return Array.isArray(r);
+}
+
+exports.default = isArray, exports.isArray = isArray, exports.isArrayNarrowed = isArray, 
+exports.isArrayPredicates = function isArrayPredicates(e, a) {
+  const t = Array.isArray(e);
+  if (!t) throw new r.AssertionError({
+    message: null != a ? a : `actual ${e} not as expected`,
+    actual: e,
+    expected: t,
+    operator: "fail"
+  });
+}, exports.typePredicatesAsReadonlyArray = function typePredicatesAsReadonlyArray(r) {}, 
+exports.typePredicatesAsWriteableArray = function typePredicatesAsWriteableArray(r) {};
 //# 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 { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":["expression","Array","isArray","actual","message","typePredicatesAsReadonlyArray","value","typePredicatesAsWriteableArray"],"mappings":"uIAYA,2IA4BE,MAAAA,EAAAC,MAAAC,QAAAC,GACF,IAACH,8BAADI,6HAHG,SAHAC,8BAAAC,GAAA,yCAASC,SAAAA,+BAA6CD,GAAA"}
+{"version":3,"file":"index.cjs.production.min.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -1,13 +1,55 @@
 import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';
 import { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';
+/**
+ * 擴展 ArrayConstructor.isArray 方法，支援更精確的類型斷言
+ * Extend ArrayConstructor.isArray method for more precise type predicate
+ *
+ * 允許在運行時檢查值是否為陣列，並在編譯時保留原始陣列類型
+ */
 declare global {
     interface ArrayConstructor {
+        /**
+         * 檢查值是否為陣列，並返回類型斷言
+         * Check if value is an array and return type predicate
+         *
+         * @param arg - 要檢查的值 / Value to check
+         * @returns 是否為陣列的類型斷言 / Type predicate indicating if it's an array
+         */
         isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T;
     }
 }
+/**
+ * 檢查值是否為陣列（類型斷言版本）
+ * Check if value is an array (type predicate version)
+ *
+ * @param arg - 要檢查的值 / Value to check
+ * @returns 是否為輸入類型的類型斷言 / Type predicate of input type
+ */
 export declare function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T;
+/**
+ * 斷言值為可變陣列（不包含 readonly 屬性）
+ * Assert value as writable array (without readonly attribute)
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
 export declare function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>;
+/**
+ * 斷言值為唯讀陣列
+ * Assert value as readonly array
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
 export declare function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>;
+/**
+ * 斷言並驗證值為陣列，否則拋出錯誤
+ * Assert and validate that value is an array, otherwise throw error
+ *
+ * @param actual - 要驗證的值 / Value to validate
+ * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)
+ * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array
+ */
 export declare function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T;
 export { isArray as isArrayNarrowed };
 export default isArray;

package/dist/index.esm.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.mjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":["typePredicatesAsWriteableArray","value","typePredicatesAsReadonlyArray","expression","Array","isArray","actual","message"],"mappings":";;;;AAYA;;AAuBYA,SAAAA,+BAA6CC,IAAA;;AAGtD,SAHAC,8BAAAD,IAAA;;;EAKD,MAAAE,IAAAC,MAAAC,QAAAC;EACF,KAACH;IAADI;;;;;;;"}
+{"version":3,"file":"index.esm.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/index.umd.development.cjs

@@ -4,14 +4,44 @@
 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.TsTypeIsArray = {}, global.assert));
 })(this, (function (exports, assert) { 'use strict';
 
+	/**
+	 * 檢查值是否為陣列（類型斷言版本）
+	 * Check if value is an array (type predicate version)
+	 *
+	 * @param arg - 要檢查的值 / Value to check
+	 * @returns 是否為輸入類型的類型斷言 / Type predicate of input type
+	 */
 	function isArray(arg) {
 	  return Array.isArray(arg);
 	}
+	/**
+	 * 斷言值為可變陣列（不包含 readonly 屬性）
+	 * Assert value as writable array (without readonly attribute)
+	 *
+	 * @param value - 要斷言的值 / Value to assert
+	 * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+	 */
+	// @ts-ignore
 	function typePredicatesAsWriteableArray(value) {}
+	/**
+	 * 斷言值為唯讀陣列
+	 * Assert value as readonly array
+	 *
+	 * @param value - 要斷言的值 / Value to assert
+	 * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+	 */
+	// @ts-ignore
 	function typePredicatesAsReadonlyArray(value) {}
+	/**
+	 * 斷言並驗證值為陣列，否則拋出錯誤
+	 * Assert and validate that value is an array, otherwise throw error
+	 *
+	 * @param actual - 要驗證的值 / Value to validate
+	 * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)
+	 * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array
+	 */
 	function isArrayPredicates(actual, message) {
 	  const expression = Array.isArray(actual);
-
 	  if (!expression) {
 	    throw new assert.AssertionError({
 	      message: message !== null && message !== void 0 ? message : `actual ${actual} not as expected`,
@@ -22,7 +52,7 @@
 	  }
 	}
 
-	exports["default"] = isArray;
+	exports.default = isArray;
 	exports.isArray = isArray;
 	exports.isArrayNarrowed = isArray;
 	exports.isArrayPredicates = isArrayPredicates;

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

@@ -1 +1 @@
-{"version":3,"file":"index.umd.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":["typePredicatesAsWriteableArray","value","expression","message"],"mappings":";;;;;;;;CAYA,CAAA;CAuBYA,SAAAA,8BAAT,CAAsDC,KAAtD,EAAsD,EAAA;CAGtD,SAHA,6BAAA,CAAA,KAAA,EAAA,EAAA;;CAKD,EAAA,MAAA,UAAA,GAAA,KAAA,CAAA,OAAA,CAAA,MAAA,CAAA,CAAA;;CACF,EAAA,IAAA,CAACC,UAAD,EAAC;;OAADC;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.umd.development.cjs","sources":["../src/index.ts"],"sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\n/**\n * 擴展 ArrayConstructor.isArray 方法，支援更精確的類型斷言\n * Extend ArrayConstructor.isArray method for more precise type predicate\n *\n * 允許在運行時檢查值是否為陣列，並在編譯時保留原始陣列類型\n */\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\t/**\n\t\t * 檢查值是否為陣列，並返回類型斷言\n\t\t * Check if value is an array and return type predicate\n\t\t *\n\t\t * @param arg - 要檢查的值 / Value to check\n\t\t * @returns 是否為陣列的類型斷言 / Type predicate indicating if it's an array\n\t\t */\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\n/**\n * 檢查值是否為陣列（類型斷言版本）\n * Check if value is an array (type predicate version)\n *\n * @param arg - 要檢查的值 / Value to check\n * @returns 是否為輸入類型的類型斷言 / Type predicate of input type\n */\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n/**\n * 斷言值為可變陣列（不包含 readonly 屬性）\n * Assert value as writable array (without readonly attribute)\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n/**\n * 斷言值為唯讀陣列\n * Assert value as readonly array\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\n/**\n * 斷言並驗證值為陣列，否則拋出錯誤\n * Assert and validate that value is an array, otherwise throw error\n *\n * @param actual - 要驗證的值 / Value to validate\n * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)\n * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array\n */\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":[],"mappings":";;;;;;;;;CA+EG;;;CAtDH;;;;;;;;;;;;;;;;;;CAsDG;;CAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,2 +1,22 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("assert")):"function"==typeof define&&define.amd?define(["exports","assert"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).TsTypeIsArray={},e.assert)}(this,(function(e,r){"use strict";function isArray(e){return Array.isArray(e)}e.default=isArray,e.isArray=isArray,e.isArrayNarrowed=isArray,e.isArrayPredicates=function isArrayPredicates(e,t){const a=Array.isArray(e);if(!a)throw new r.AssertionError({message:null!=t?t:`actual ${e} not as expected`,actual:e,expected:a,operator:"fail"})},e.typePredicatesAsReadonlyArray=function typePredicatesAsReadonlyArray(e){},e.typePredicatesAsWriteableArray=function typePredicatesAsWriteableArray(e){},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e, r) {
+  "object" == typeof exports && "undefined" != typeof module ? r(exports, require("assert")) : "function" == typeof define && define.amd ? define([ "exports", "assert" ], r) : r((e = "undefined" != typeof globalThis ? globalThis : e || self).TsTypeIsArray = {}, e.assert);
+}(this, function(e, r) {
+  "use strict";
+  function isArray(e) {
+    return Array.isArray(e);
+  }
+  e.default = isArray, e.isArray = isArray, e.isArrayNarrowed = isArray, e.isArrayPredicates = function isArrayPredicates(e, t) {
+    const a = Array.isArray(e);
+    if (!a) throw new r.AssertionError({
+      message: null != t ? t : `actual ${e} not as expected`,
+      actual: e,
+      expected: a,
+      operator: "fail"
+    });
+  }, e.typePredicatesAsReadonlyArray = function typePredicatesAsReadonlyArray(e) {}, 
+  e.typePredicatesAsWriteableArray = function typePredicatesAsWriteableArray(e) {}, 
+  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 { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"],"names":["expression","Array","isArray","actual","message","typePredicatesAsReadonlyArray","value","typePredicatesAsWriteableArray"],"mappings":"sUAYA,mHA4BE,MAAAA,EAAAC,MAAAC,QAAAC,GACF,IAACH,8BAADI,uHAHG,SAHAC,8BAAAC,GAAA,mCAASC,SAAAA,+BAA6CD,GAAA"}
+{"version":3,"file":"index.umd.production.min.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ts-type/is-array",
-  "version": "1.0.6",
-  "description": "better typescript type for Array.isArray",
+  "version": "1.0.7",
+  "description": "增強的陣列類型斷言與驗證工具 | Enhanced array type predicates and validation utilities",
   "keywords": [
     ".d.ts",
     "@types",
@@ -43,8 +43,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"
   },
@@ -61,13 +61,14 @@
     "lint": "yarn run lint:eslint",
     "lint:eslint": "ynpx eslint --ext .ts,.tsx,.mts,.cts ./",
     "pretest": "echo pretest",
-    "test": "ts-node ./test/spec/issues-17002.spec.ts",
+    "test": "tsx ./test/spec/issues-17002.spec.ts",
     "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 --inline-declare-externals & echo build:dts",
@@ -75,7 +76,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",
@@ -96,11 +97,10 @@
     "tsc:showConfig": "ynpx get-current-tsconfig -p"
   },
   "dependencies": {
-    "ts-type": "^3.0.1"
+    "ts-type": "^3.0.2"
   },
-  "packageManager": "yarn@^1.22.11",
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fa34eea119b9bcbb363061ddffcfe9d78c2d0ddd"
+  "gitHead": "57f82cba146cfef0d0f3f138e5ec736cd17f040d"
 }

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AACA,mCAAwC;AAWxC,SAAgB,OAAO,CAA2C,GAAgB;IAEjF,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAHD,0BAGC;AA4BmB,kCAAe;AA1BnC,aAAa;AACb,SAAgB,8BAA8B,CAA2C,KAAQ;AAGjG,CAAC;AAHD,wEAGC;AAED,aAAa;AACb,SAAgB,6BAA6B,CAA2C,KAAQ;AAGhG,CAAC;AAHD,sEAGC;AAED,SAAgB,iBAAiB,CAA2C,MAAmB,EAAE,OAAgB;IAEhH,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,UAAU,EACf;QACC,MAAM,IAAI,uBAAc,CAAC;YACxB,OAAO,EAAE,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,UAAU,MAAM,kBAAkB;YACtD,MAAM;YACN,QAAQ,EAAE,UAAU;YACpB,QAAQ,EAAE,MAAM;SAChB,CAAC,CAAA;KACF;AACF,CAAC;AAZD,8CAYC;AAID,kBAAe,OAAO,CAAA","sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;AAgCA,0BAGC;AAkDmB,kCAAe;AAxCnC,wEAGC;AAUD,sEAGC;AAUD,8CAYC;AAlFD,mCAAwC;AAwBxC;;;;;;GAMG;AACH,SAAgB,OAAO,CAA2C,GAAgB;IAEjF,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,aAAa;AACb,SAAgB,8BAA8B,CAA2C,KAAQ;AAGjG,CAAC;AAED;;;;;;GAMG;AACH,aAAa;AACb,SAAgB,6BAA6B,CAA2C,KAAQ;AAGhG,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,iBAAiB,CAA2C,MAAmB,EAAE,OAAgB;IAEhH,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,UAAU,EACf,CAAC;QACA,MAAM,IAAI,uBAAc,CAAC;YACxB,OAAO,EAAE,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,UAAU,MAAM,kBAAkB;YACtD,MAAM;YACN,QAAQ,EAAE,UAAU;YACpB,QAAQ,EAAE,MAAM;SAChB,CAAC,CAAA;IACH,CAAC;AACF,CAAC;AAID,kBAAe,OAAO,CAAA","sourcesContent":["import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';\nimport { AssertionError } from 'assert';\nimport { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';\n\n/**\n * 擴展 ArrayConstructor.isArray 方法，支援更精確的類型斷言\n * Extend ArrayConstructor.isArray method for more precise type predicate\n *\n * 允許在運行時檢查值是否為陣列，並在編譯時保留原始陣列類型\n */\ndeclare global\n{\n\tinterface ArrayConstructor\n\t{\n\t\t/**\n\t\t * 檢查值是否為陣列，並返回類型斷言\n\t\t * Check if value is an array and return type predicate\n\t\t *\n\t\t * @param arg - 要檢查的值 / Value to check\n\t\t * @returns 是否為陣列的類型斷言 / Type predicate indicating if it's an array\n\t\t */\n\t\tisArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n\t}\n}\n\n/**\n * 檢查值是否為陣列（類型斷言版本）\n * Check if value is an array (type predicate version)\n *\n * @param arg - 要檢查的值 / Value to check\n * @returns 是否為輸入類型的類型斷言 / Type predicate of input type\n */\nexport function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T\n{\n\treturn Array.isArray(arg)\n}\n\n/**\n * 斷言值為可變陣列（不包含 readonly 屬性）\n * Assert value as writable array (without readonly attribute)\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>\n{\n\n}\n\n/**\n * 斷言值為唯讀陣列\n * Assert value as readonly array\n *\n * @param value - 要斷言的值 / Value to assert\n * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array\n */\n// @ts-ignore\nexport function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>\n{\n\n}\n\n/**\n * 斷言並驗證值為陣列，否則拋出錯誤\n * Assert and validate that value is an array, otherwise throw error\n *\n * @param actual - 要驗證的值 / Value to validate\n * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)\n * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array\n */\nexport function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T\n{\n\tconst expression = Array.isArray(actual);\n\tif (!expression)\n\t{\n\t\tthrow new AssertionError({\n\t\t\tmessage: message ?? `actual ${actual} not as expected`,\n\t\t\tactual,\n\t\t\texpected: expression,\n\t\t\toperator: 'fail',\n\t\t})\n\t}\n}\n\nexport { isArray as isArrayNarrowed }\n\nexport default isArray\n"]}

package/src/index.ts

@@ -2,31 +2,73 @@ import { ITSArrayListMaybeReadonly } from 'ts-type/lib/type/base';
 import { AssertionError } from 'assert';
 import { ITSToReadonlyArray, ITSToWriteableArray } from 'ts-type/lib/helper/array/readonly';
 
+/**
+ * 擴展 ArrayConstructor.isArray 方法，支援更精確的類型斷言
+ * Extend ArrayConstructor.isArray method for more precise type predicate
+ *
+ * 允許在運行時檢查值是否為陣列，並在編譯時保留原始陣列類型
+ */
 declare global
 {
 	interface ArrayConstructor
 	{
+		/**
+		 * 檢查值是否為陣列，並返回類型斷言
+		 * Check if value is an array and return type predicate
+		 *
+		 * @param arg - 要檢查的值 / Value to check
+		 * @returns 是否為陣列的類型斷言 / Type predicate indicating if it's an array
+		 */
 		isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T
 	}
 }
 
+/**
+ * 檢查值是否為陣列（類型斷言版本）
+ * Check if value is an array (type predicate version)
+ *
+ * @param arg - 要檢查的值 / Value to check
+ * @returns 是否為輸入類型的類型斷言 / Type predicate of input type
+ */
 export function isArray<T extends ITSArrayListMaybeReadonly<any>>(arg: T | unknown): arg is T
 {
 	return Array.isArray(arg)
 }
 
+/**
+ * 斷言值為可變陣列（不包含 readonly 屬性）
+ * Assert value as writable array (without readonly attribute)
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
 // @ts-ignore
 export function typePredicatesAsWriteableArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToWriteableArray<T>
 {
 
 }
 
+/**
+ * 斷言值為唯讀陣列
+ * Assert value as readonly array
+ *
+ * @param value - 要斷言的值 / Value to assert
+ * @throws 當值不是陣列時拋出錯誤 / Throws error when value is not an array
+ */
 // @ts-ignore
 export function typePredicatesAsReadonlyArray<T extends ITSArrayListMaybeReadonly<any>>(value: T): asserts value is ITSToReadonlyArray<T>
 {
 
 }
 
+/**
+ * 斷言並驗證值為陣列，否則拋出錯誤
+ * Assert and validate that value is an array, otherwise throw error
+ *
+ * @param actual - 要驗證的值 / Value to validate
+ * @param message - 自訂錯誤訊息（可選）/ Custom error message (optional)
+ * @throws 當值不是陣列時拋出 AssertionError / Throws AssertionError when value is not an array
+ */
 export function isArrayPredicates<T extends ITSArrayListMaybeReadonly<any>>(actual: T | unknown, message?: string): asserts actual is T
 {
 	const expression = Array.isArray(actual);