composition-ts 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),Array.isArray,Array.from,Array.prototype.concat,Array.prototype.filter,Array.prototype.push,Array.prototype.slice,Array.prototype.splice,Function.prototype.toString;const e=Object.defineProperty,t=Object.defineProperties,n=Object.getOwnPropertyDescriptors;Number.isNaN,Number.isInteger,Number.isSafeInteger,Number.isFinite;function r(e){if(typeof e!=`function`)return!0;try{return new new Proxy(e,{construct(){return{}}}),!1}catch{return!0}}
+/**
+* Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.
+* - `initializer` **must not** be an arrow function!
+* - returned class's name is `initializer.name`
+*
+* @param initializer A function that initializes the instance. It will be called with the instance as `this` and use the arguments passed to the constructor.
+* @param parts An array of objects whose properties will be copied(via descriptors) to the prototype of the new class.
+*
+* ## About
+* @package CompositionTs
+* @author Kasukabe Tsumugi <futami16237@gmail.com>
+* @version 0.1.3 (Last Update: 2026.10.12 10:06:57.524)
+* @license MIT
+* @link git+https://github.com/baendlorel/tsumugi-lib.git
+* @link https://baendlorel.github.io/ Welcome to my site!
+* @description Instead of inheritance, make it composition!
+* @copyright Copyright (c) 2026 Kasukabe Tsumugi. All rights reserved.
+*/
+function i(i,...a){if(r(i))throw TypeError(`First argument must be a non-arrow function because it cannot access the instance's 'this' context.`);let o=e(class{constructor(...e){i.apply(this,e)}},`name`,{value:i.name,configurable:!0});for(let e=0;e<a.length;e++){let r=n(a[e]);t(o.prototype,r)}return o}exports.compose=i;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["$define","$defines","$getOwnPropertyDescriptors","notNewable","value","compose","parts","initializer","NewClass","args","i","descriptors"],"sources":["../../_shared/native/std.ts","../src/index.ts"],"sourcesContent":["// Cached native methods for performance optimization\n\n// # Array\nexport const $isArray = Array.isArray;\nexport const $arrayFrom = Array.from;\nexport const $concat = Array.prototype.concat;\nexport const $filter = Array.prototype.filter;\nexport const $push = Array.prototype.push;\nexport const $slice = Array.prototype.slice;\nexport const $splice = Array.prototype.splice;\n\n// # Object\nexport const $fnToString = Function.prototype.toString;\nexport const $toString = Object.prototype.toString;\nexport const $ObjectPrototype = Object.prototype;\nexport const $is = Object.is;\nexport const $assign = Object.assign;\nexport const $hasOwn = Object.prototype.hasOwnProperty;\nexport const $keys = Object.keys as <T>(o: T) => Array<keyof T>;\nexport const $define = Object.defineProperty;\nexport const $defines = Object.defineProperties;\nexport const $entries = Object.entries as <T>(o: T) => Array<[keyof T, T[keyof T]]>;\nexport const $jsonStringify = JSON.stringify;\nexport const $getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;\nexport const $freeze = Object.freeze;\n\n// # Reflect\n\nexport const $set = Reflect.set;\nexport const $get = Reflect.get;\nexport const $has = Reflect.has;\nexport const $ownKeys = Reflect.ownKeys;\n// & Do not use `Object.defineProperty`\nexport const $reflectDefine = Reflect.defineProperty;\nexport const $delete = Reflect.deleteProperty;\nexport const $getPrototypeOf = Reflect.getPrototypeOf;\nexport const $setPrototypeOf = Reflect.setPrototypeOf;\n\n// # Math and related utilities\nexport const $max = Math.max;\nexport const $min = Math.min;\nexport const $floor = Math.floor;\nexport const $random = Math.random;\nexport const $randomInt = (min: number, max: number) => $floor($random() * (max - min + 1)) + min;\n\n// # Number\nexport const $isNaN = Number.isNaN;\nexport const $isInt = Number.isInteger;\nexport const $isSafeInt = Number.isSafeInteger;\nexport const $isFinite = Number.isFinite;\nexport const $MAX_INT = Number.MAX_SAFE_INTEGER;\nexport const $MIN_INT = Number.MIN_SAFE_INTEGER;\n\nexport const $isThenable = (o: any): o is Promise<any> => typeof o?.then === 'function';\n\nexport const $isPrimitive: (o: unknown) => boolean | null | undefined | symbol | number | bigint = (o) =>\n  o === null || (typeof o !== 'object' && typeof o !== 'function');\n","import type { Compose, Constructor, Mutable } from './types.js';\nimport { $define, $defines, $getOwnPropertyDescriptors } from '@shared';\n\nfunction notNewable(value: unknown): value is new (...args: unknown[]) => unknown {\n  if (typeof value !== 'function') {\n    return true;\n  }\n  try {\n    const a = new Proxy(value as Constructor, {\n      construct() {\n        return {};\n      },\n    });\n    new a();\n    return false;\n  } catch {\n    return true;\n  }\n}\n\n/**\n * Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.\n * - `initializer` **must not** be an arrow function!\n * - returned class's name is `initializer.name`\n *\n * @param initializer A function that initializes the instance. It will be called with the instance as `this` and use the arguments passed to the constructor.\n * @param parts An array of objects whose properties will be copied(via descriptors) to the prototype of the new class.\n *\n * __PKG_INFO__\n */\nexport function compose<\n  Protos extends readonly object[],\n  Args extends any[],\n  Instance extends Compose<Protos> = Compose<Protos>,\n>(initializer: (this: Mutable<Instance>, ...args: Args) => any, ...parts: Protos): new (...args: Args) => Instance {\n  if (notNewable(initializer)) {\n    throw new TypeError(\n      `First argument must be a non-arrow function because it cannot access the instance's 'this' context.`,\n    );\n  }\n\n  const NewClass = $define(\n    class {\n      constructor(...args: Args) {\n        initializer.apply(this as any, args);\n      }\n    },\n    'name',\n    {\n      value: initializer.name,\n      configurable: true,\n    },\n  );\n\n  for (let i = 0; i < parts.length; i++) {\n    const descriptors = $getOwnPropertyDescriptors(parts[i]);\n    $defines(NewClass.prototype, descriptors);\n  }\n\n  return NewClass as new (...params: Args) => Instance;\n}\n"],"mappings":"mEAGwB,MAAM,QACJ,MAAM,KACT,MAAM,UAAU,OAChB,MAAM,UAAU,OAClB,MAAM,UAAU,KACf,MAAM,UAAU,MACf,MAAM,UAAU,OAGZ,SAAS,UAAU,SAO9C,MAAaA,EAAU,OAAO,eACjBC,EAAW,OAAO,iBAGlBC,EAA6B,OAAO,0BAuB3B,OAAO,MACP,OAAO,UACH,OAAO,cACR,OAAO,SC9ChC,SAASC,EAAW,EAA8D,CAChF,GAAI,OAAOC,GAAU,WACnB,MAAO,GAET,GAAI,CAOF,OADA,IAAI,IALU,MAAMA,EAAsB,CACxC,WAAY,CACV,MAAO,CAAC,CACV,CACF,CACI,EACG,EACT,MAAQ,CACN,MAAO,EACT,CACF;;;;;;;;;;;;;;;;;;;AAYA,SAAgBC,EAId,EAA8D,GAAGC,EAAgD,CACjH,GAAIH,EAAWI,CAAW,EACxB,MAAU,UACR,qGACF,EAGF,IAAMC,EAAWR,EACf,KAAM,CACJ,YAAY,GAAGS,EAAY,CACzBF,EAAY,MAAM,KAAaE,CAAI,CACrC,CACF,EACA,OACA,CACE,MAAOF,EAAY,KACnB,aAAc,EAChB,CACF,EAEA,IAAK,IAAIG,EAAI,EAAGA,EAAIJ,EAAM,OAAQ,IAAK,CACrC,IAAMK,EAAcT,EAA2BI,EAAMI,EAAE,EACvDT,EAASO,EAAS,UAAWG,CAAW,CAC1C,CAEA,OAAOH,CACT"}

package/dist/index.d.cts

@@ -0,0 +1,19 @@
+//#region src/types.d.ts
+type Compose<Types extends readonly unknown[]> = Types extends readonly [infer Head, ...infer Tail] ? Head & Compose<Tail> : unknown;
+type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
+//#endregion
+//#region src/index.d.ts
+/**
+ * Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.
+ * - `initializer` **must not** be an arrow function!
+ * - returned class's name is `initializer.name`
+ *
+ * @param initializer A function that initializes the instance. It will be called with the instance as `this` and use the arguments passed to the constructor.
+ * @param parts An array of objects whose properties will be copied(via descriptors) to the prototype of the new class.
+ *
+ * __PKG_INFO__
+ */
+declare function compose<Protos extends readonly object[], Args extends any[], Instance extends Compose<Protos> = Compose<Protos>>(initializer: (this: Mutable<Instance>, ...args: Args) => any, ...parts: Protos): new (...args: Args) => Instance;
+//#endregion
+export { compose };
+//# sourceMappingURL=index.d.cts.map

package/dist/{index.d.ts → index.d.mts}

@@ -1,10 +1,8 @@
-type Compose<Types extends readonly unknown[]> = Types extends readonly [infer Head, ...infer Tail]
-  ? Head & Compose<Tail>
-  : unknown;
-type Mutable<T> = {
-  -readonly [P in keyof T]: T[P];
-};
-
+//#region src/types.d.ts
+type Compose<Types extends readonly unknown[]> = Types extends readonly [infer Head, ...infer Tail] ? Head & Compose<Tail> : unknown;
+type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
+//#endregion
+//#region src/index.d.ts
 /**
  * Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.
  * - `initializer` **must not** be an arrow function!
@@ -16,13 +14,14 @@ type Mutable<T> = {
  * ## About
  * @package CompositionTs
  * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 0.1.2 (Last Update: 2026.03.26 11:27:32.645)
+ * @version 0.1.3 (Last Update: 2026.10.12 10:06:57.524)
  * @license MIT
- * @link git+https://github.com/baendlorel/kt-packages.git
+ * @link git+https://github.com/baendlorel/tsumugi-lib.git
  * @link https://baendlorel.github.io/ Welcome to my site!
  * @description Instead of inheritance, make it composition!
  * @copyright Copyright (c) 2026 Kasukabe Tsumugi. All rights reserved.
  */
 declare function compose<Protos extends readonly object[], Args extends any[], Instance extends Compose<Protos> = Compose<Protos>>(initializer: (this: Mutable<Instance>, ...args: Args) => any, ...parts: Protos): new (...args: Args) => Instance;
-
+//#endregion
 export { compose };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,29 +1,21 @@
-const t = Object.defineProperty, n = Object.defineProperties, e = Object.getOwnPropertyDescriptors;
-
-function c(c, ...r) {
-  if (function(t) {
-    if ("function" != typeof t) return !0;
-    try {
-      return new new Proxy(t, {
-        construct: () => ({})
-      }), !1;
-    } catch {
-      return !0;
-    }
-  }(c)) throw new TypeError("First argument must be a non-arrow function because it cannot access the instance's 'this' context.");
-  const o = t(class {
-    constructor(...t) {
-      c.apply(this, t);
-    }
-  }, "name", {
-    value: c.name,
-    configurable: !0
-  });
-  for (let t = 0; t < r.length; t++) {
-    const c = e(r[t]);
-    n(o.prototype, c);
-  }
-  return o;
-}
-
-export { c as compose };
+Array.isArray,Array.from,Array.prototype.concat,Array.prototype.filter,Array.prototype.push,Array.prototype.slice,Array.prototype.splice,Function.prototype.toString;const e=Object.defineProperty,t=Object.defineProperties,n=Object.getOwnPropertyDescriptors;Number.isNaN,Number.isInteger,Number.isSafeInteger,Number.isFinite;function r(e){if(typeof e!=`function`)return!0;try{return new new Proxy(e,{construct(){return{}}}),!1}catch{return!0}}
+/**
+* Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.
+* - `initializer` **must not** be an arrow function!
+* - returned class's name is `initializer.name`
+*
+* @param initializer A function that initializes the instance. It will be called with the instance as `this` and use the arguments passed to the constructor.
+* @param parts An array of objects whose properties will be copied(via descriptors) to the prototype of the new class.
+*
+* ## About
+* @package CompositionTs
+* @author Kasukabe Tsumugi <futami16237@gmail.com>
+* @version 0.1.3 (Last Update: 2026.10.12 10:06:57.524)
+* @license MIT
+* @link git+https://github.com/baendlorel/tsumugi-lib.git
+* @link https://baendlorel.github.io/ Welcome to my site!
+* @description Instead of inheritance, make it composition!
+* @copyright Copyright (c) 2026 Kasukabe Tsumugi. All rights reserved.
+*/
+function i(i,...a){if(r(i))throw TypeError(`First argument must be a non-arrow function because it cannot access the instance's 'this' context.`);let o=e(class{constructor(...e){i.apply(this,e)}},`name`,{value:i.name,configurable:!0});for(let e=0;e<a.length;e++){let r=n(a[e]);t(o.prototype,r)}return o}export{i as compose};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["$define","$defines","$getOwnPropertyDescriptors","notNewable","value","compose","parts","initializer","NewClass","args","i","descriptors"],"sources":["../../_shared/native/std.ts","../src/index.ts"],"sourcesContent":["// Cached native methods for performance optimization\n\n// # Array\nexport const $isArray = Array.isArray;\nexport const $arrayFrom = Array.from;\nexport const $concat = Array.prototype.concat;\nexport const $filter = Array.prototype.filter;\nexport const $push = Array.prototype.push;\nexport const $slice = Array.prototype.slice;\nexport const $splice = Array.prototype.splice;\n\n// # Object\nexport const $fnToString = Function.prototype.toString;\nexport const $toString = Object.prototype.toString;\nexport const $ObjectPrototype = Object.prototype;\nexport const $is = Object.is;\nexport const $assign = Object.assign;\nexport const $hasOwn = Object.prototype.hasOwnProperty;\nexport const $keys = Object.keys as <T>(o: T) => Array<keyof T>;\nexport const $define = Object.defineProperty;\nexport const $defines = Object.defineProperties;\nexport const $entries = Object.entries as <T>(o: T) => Array<[keyof T, T[keyof T]]>;\nexport const $jsonStringify = JSON.stringify;\nexport const $getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;\nexport const $freeze = Object.freeze;\n\n// # Reflect\n\nexport const $set = Reflect.set;\nexport const $get = Reflect.get;\nexport const $has = Reflect.has;\nexport const $ownKeys = Reflect.ownKeys;\n// & Do not use `Object.defineProperty`\nexport const $reflectDefine = Reflect.defineProperty;\nexport const $delete = Reflect.deleteProperty;\nexport const $getPrototypeOf = Reflect.getPrototypeOf;\nexport const $setPrototypeOf = Reflect.setPrototypeOf;\n\n// # Math and related utilities\nexport const $max = Math.max;\nexport const $min = Math.min;\nexport const $floor = Math.floor;\nexport const $random = Math.random;\nexport const $randomInt = (min: number, max: number) => $floor($random() * (max - min + 1)) + min;\n\n// # Number\nexport const $isNaN = Number.isNaN;\nexport const $isInt = Number.isInteger;\nexport const $isSafeInt = Number.isSafeInteger;\nexport const $isFinite = Number.isFinite;\nexport const $MAX_INT = Number.MAX_SAFE_INTEGER;\nexport const $MIN_INT = Number.MIN_SAFE_INTEGER;\n\nexport const $isThenable = (o: any): o is Promise<any> => typeof o?.then === 'function';\n\nexport const $isPrimitive: (o: unknown) => boolean | null | undefined | symbol | number | bigint = (o) =>\n  o === null || (typeof o !== 'object' && typeof o !== 'function');\n","import type { Compose, Constructor, Mutable } from './types.js';\nimport { $define, $defines, $getOwnPropertyDescriptors } from '@shared';\n\nfunction notNewable(value: unknown): value is new (...args: unknown[]) => unknown {\n  if (typeof value !== 'function') {\n    return true;\n  }\n  try {\n    const a = new Proxy(value as Constructor, {\n      construct() {\n        return {};\n      },\n    });\n    new a();\n    return false;\n  } catch {\n    return true;\n  }\n}\n\n/**\n * Instead of using class inheritance, we can compose prototypes from multiple objects. This function takes a constructor function and an array of objects, and returns a new class that creates instances with the combined prototype of all the objects.\n * - `initializer` **must not** be an arrow function!\n * - returned class's name is `initializer.name`\n *\n * @param initializer A function that initializes the instance. It will be called with the instance as `this` and use the arguments passed to the constructor.\n * @param parts An array of objects whose properties will be copied(via descriptors) to the prototype of the new class.\n *\n * __PKG_INFO__\n */\nexport function compose<\n  Protos extends readonly object[],\n  Args extends any[],\n  Instance extends Compose<Protos> = Compose<Protos>,\n>(initializer: (this: Mutable<Instance>, ...args: Args) => any, ...parts: Protos): new (...args: Args) => Instance {\n  if (notNewable(initializer)) {\n    throw new TypeError(\n      `First argument must be a non-arrow function because it cannot access the instance's 'this' context.`,\n    );\n  }\n\n  const NewClass = $define(\n    class {\n      constructor(...args: Args) {\n        initializer.apply(this as any, args);\n      }\n    },\n    'name',\n    {\n      value: initializer.name,\n      configurable: true,\n    },\n  );\n\n  for (let i = 0; i < parts.length; i++) {\n    const descriptors = $getOwnPropertyDescriptors(parts[i]);\n    $defines(NewClass.prototype, descriptors);\n  }\n\n  return NewClass as new (...params: Args) => Instance;\n}\n"],"mappings":"AAGwB,MAAM,QACJ,MAAM,KACT,MAAM,UAAU,OAChB,MAAM,UAAU,OAClB,MAAM,UAAU,KACf,MAAM,UAAU,MACf,MAAM,UAAU,OAGZ,SAAS,UAAU,SAO9C,MAAaA,EAAU,OAAO,eACjBC,EAAW,OAAO,iBAGlBC,EAA6B,OAAO,0BAuB3B,OAAO,MACP,OAAO,UACH,OAAO,cACR,OAAO,SC9ChC,SAASC,EAAW,EAA8D,CAChF,GAAI,OAAOC,GAAU,WACnB,MAAO,GAET,GAAI,CAOF,OADA,IAAI,IALU,MAAMA,EAAsB,CACxC,WAAY,CACV,MAAO,CAAC,CACV,CACF,CACI,EACG,EACT,MAAQ,CACN,MAAO,EACT,CACF;;;;;;;;;;;;;;;;;;;AAYA,SAAgBC,EAId,EAA8D,GAAGC,EAAgD,CACjH,GAAIH,EAAWI,CAAW,EACxB,MAAU,UACR,qGACF,EAGF,IAAMC,EAAWR,EACf,KAAM,CACJ,YAAY,GAAGS,EAAY,CACzBF,EAAY,MAAM,KAAaE,CAAI,CACrC,CACF,EACA,OACA,CACE,MAAOF,EAAY,KACnB,aAAc,EAChB,CACF,EAEA,IAAK,IAAIG,EAAI,EAAGA,EAAIJ,EAAM,OAAQ,IAAK,CACrC,IAAMK,EAAcT,EAA2BI,EAAMI,EAAE,EACvDT,EAASO,EAAS,UAAWG,CAAW,CAC1C,CAEA,OAAOH,CACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "composition-ts",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": {
     "name": "Kasukabe Tsumugi",
     "email": "futami16237@gmail.com"
@@ -21,7 +21,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/baendlorel/kt-packages.git",
+    "url": "git+https://github.com/baendlorel/tsumugi-lib.git",
     "directory": "packages/composition-ts"
   },
   "keywords": [
@@ -30,7 +30,7 @@
   ],
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/baendlorel/kt-packages/issues"
+    "url": "https://github.com/baendlorel/tsumugi-lib/issues"
   },
-  "homepage": "https://github.com/baendlorel/kt-packages/tree/main/packages/composition-ts#readme"
-}
+  "homepage": "https://github.com/baendlorel/tsumugi-lib/tree/main/packages/composition-ts#readme"
+}