composition-ts 0.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,38 @@
+# Composition TS
+
+Compose any number of types into a single intersection type.
+
+## Usage
+
+```ts
+import type { Compose } from 'composition-ts';
+
+type Result = Compose<[{ id: number }, { name: string }, { active: boolean }]>;
+
+// Result:
+// { id: number } & { name: string } & { active: boolean }
+```
+
+## API
+
+### Compose<Types>
+
+Intersects every type in the tuple from left to right.
+
+```ts
+type Empty = Compose<[]>; // unknown
+type Single = Compose<[string]>; // string
+type Mixed = Compose<[string, number]>; // never
+```
+
+### IntersectAll<Types>
+
+Alias of Compose<Types>.
+
+## License
+
+MIT
+
+```
+
+```

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+type Compose<Types extends readonly unknown[]> = Types extends readonly [infer Head, ...infer Tail]
+  ? Head & Compose<Tail>
+  : unknown;
+
+/**
+ * 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!
+ *
+ * @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.
+ * @param className An optional name for the new class. If not provided, it will default to the name of the `initializer` function.
+ *
+ * ## About
+ * @package CompositionTs
+ * @author Kasukabe Tsumugi <futami16237@gmail.com>
+ * @version 0.0.0 (Last Update: 2026.03.26 10:24:23.468)
+ * @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;
+
+export { compose };

package/dist/index.mjs

@@ -0,0 +1,29 @@
+const t = Object.defineProperty, n = Object.defineProperties, e = Object.getOwnPropertyDescriptors;
+
+function c(c, r, o) {
+  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 s = t(class {
+    constructor(...t) {
+      c.apply(this, t);
+    }
+  }, "name", {
+    value: o ?? c.name,
+    configurable: !0
+  });
+  for (let t = 0; t < r.length; t++) {
+    const c = e(r[t]);
+    n(s.prototype, c);
+  }
+  return s;
+}
+
+export { c as compose };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "composition-ts",
+  "version": "0.0.0",
+  "author": {
+    "name": "Kasukabe Tsumugi",
+    "email": "futami16237@gmail.com"
+  },
+  "purpose": "npm",
+  "description": "Instead of inheritance, make it composition!",
+  "description_zh": "不使用继承，使用组合吧！",
+  "type": "module",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.mjs",
+    "default": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baendlorel/kt-packages.git",
+    "directory": "packages/composition-ts"
+  },
+  "keywords": [
+    "typescript",
+    "javascript"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/baendlorel/kt-packages/issues"
+  },
+  "homepage": "https://github.com/baendlorel/kt-packages/tree/main/packages/composition-ts#readme"
+}