composition-ts 0.0.0 → 0.1.0

package/README.md

@@ -1,38 +1,72 @@
 # Composition TS
 
-Compose any number of types into a single intersection type.
+Instead of inheritance, compose prototype parts into a generated class.
 
 ## Usage
 
 ```ts
-import type { Compose } from 'composition-ts';
+import { compose } from 'composition-ts';
 
-type Result = Compose<[{ id: number }, { name: string }, { active: boolean }]>;
+const statePart = {
+  id: 0,
+  name: '',
+};
 
-// Result:
-// { id: number } & { name: string } & { active: boolean }
+const renamable = {
+  rename(this: typeof statePart, next: string) {
+    this.name = next;
+    return this.name;
+  },
+};
+
+const describable = {
+  get label() {
+    const self = this as typeof statePart;
+    return `${self.id}:${self.name}`;
+  },
+};
+
+const PersonModel = compose(
+  function Person(this: Person, id: number, name: string) {
+    this.id = id;
+    this.name = name;
+  },
+  [statePart, renamable, describable],
+  'PersonModel',
+);
+
+const person = new PersonModel(1, 'Ada');
+
+person.rename('Grace');
+console.log(person.label); // 1:Grace
 ```
 
 ## API
 
-### Compose<Types>
+### compose(initializer, parts, className?)
 
-Intersects every type in the tuple from left to right.
+Creates a new class and copies every property descriptor from `parts` onto its prototype.
 
 ```ts
-type Empty = Compose<[]>; // unknown
-type Single = Compose<[string]>; // string
-type Mixed = Compose<[string, number]>; // never
+declare function compose<Protos extends readonly object[], Args extends any[], Instance extends Compose<Protos>>(
+  initializer: (this: Instance, ...args: Args) => any,
+  parts: Protos,
+  className?: string,
+): new (...args: Args) => Instance;
 ```
 
-### IntersectAll<Types>
+Parameters:
 
-Alias of Compose<Types>.
+- `initializer`: A regular function invoked inside the generated constructor with the new instance bound as `this`.
+- `parts`: An array of objects whose own property descriptors are copied onto the generated class prototype.
+- `className`: Optional class name for the generated constructor. Defaults to `initializer.name`.
 
-## License
+Notes:
 
-MIT
+- `initializer` must be a regular function. Arrow functions cannot receive the instance through `this`.
+- Property descriptors are copied as-is, so getters, setters, enumerability, and writability are preserved.
+- When multiple parts define the same key, later parts overwrite earlier ones.
 
-```
+## License
 
-```
+MIT

package/dist/index.d.ts

@@ -13,13 +13,13 @@ type Compose<Types extends readonly unknown[]> = Types extends readonly [infer H
  * ## About
  * @package CompositionTs
  * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 0.0.0 (Last Update: 2026.03.26 10:24:23.468)
+ * @version 0.1.0 (Last Update: 2026.03.26 11:15:42.072)
  * @license MIT
  * @link git+https://github.com/baendlorel/kt-packages.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>>(initializer: (this: Instance, ...args: Args) => any, parts: Protos, className?: string): new (...args: Args) => Instance;
+declare function compose<Protos extends readonly object[], Args extends any[], Instance extends Compose<Protos> = Compose<Protos>>(initializer: (this: Instance, ...args: Args) => any, parts: Protos, className?: string): new (...args: Args) => Instance;
 
 export { compose };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "composition-ts",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "author": {
     "name": "Kasukabe Tsumugi",
     "email": "futami16237@gmail.com"