@asterflow/plugin 1.0.9 → 1.1.0

package/README.md

@@ -4,148 +4,63 @@
 
 ![license-info](https://img.shields.io/github/license/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
 ![stars-info](https://img.shields.io/github/stars/AsterFlow/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
-![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Fresponse&style=for-the-badge&colorA=302D41&colorB=b4befe)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Fplugin&style=for-the-badge&colorA=302D41&colorB=b4befe)
 
 ![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/plugin?style=for-the-badge&colorA=302D41&colorB=3ac97b)
 
 </div>
 
-> A modular and typed plugin system for extending AsterFlow functionality.
+> The plugin-authoring system used to build AsterFlow plugins - a typed builder for context, config and lifecycle hooks.
 
 ## 📦 Installation
 
 ```bash
-npm install @asterflow/plugin
-# or
 bun install @asterflow/plugin
 ```
 
-## 💡 About
+### ✨ Features
 
-`@asterflow/plugin` provides a robust and typed system for extending AsterFlow's functionality. It allows developers to create modular plugins that can inject context, manipulate configurations, and react to application lifecycle events, ensuring seamless and type-safe integration.
+- **Fluent builder:** chain `.config()`, `.decorate()`, `.derive()`, `.extends()` and `.on()` off a single `Plugin.create({ name })` call.
+- **Typed config with defaults:** `.config()` sets the plugin's default config and infers its shape.
+- **Static and derived context:** `.decorate()` injects a fixed value; `.derive()` computes a value from the config and context already built, lazily, when the plugin is registered.
+- **Instance extensions:** `.extends()` adds new properties/methods to the AsterFlow instance, computed from the app and the plugin's context.
+- **Lifecycle hooks:** `.on()` registers handlers for `beforeInitialize`, `afterInitialize`, `onRequest` and `onResponse`.
+- **Type inference end-to-end:** every chained call narrows a single `Props` type, so config, context and extensions stay typed without manual generics.
 
-## ✨ Features
+## ❓ How to Use
 
--   **Extensible Plugin System:** Create modular plugins to add custom functionalities to AsterFlow.
--   **Dynamic Context:** Inject static values into the plugin's context (`decorate`) or derive complex properties based on configuration and existing context (`derive`).
--   **Lifecycle Hooks:** Register handlers for specific AsterFlow application events (such as `beforeInitialize`, `afterInitialize`, `onRequest`, and `onResponse`) to extend behavior at different stages.
--   **Typed Configuration:** Define the plugin's configuration structure and its default values, with automatic type inference.
--   **Type Safety:** Full TypeScript support to ensure your plugin's context, configuration, and hooks are type-safe.
--   **Runtime Optimization:** Hooks are efficiently invoked only when the plugin is registered, allowing for performance optimizations.
+Build a plugin with `Plugin.create`, then chain the pieces it needs. This one adds a config option and exposes a method on the AsterFlow instance:
 
-## 🚀 Usage
-
-`@asterflow/plugin` enables the creation of plugins that extend `AsterFlow` in a modular and type-safe manner. Below are examples of how to create and use plugins.
-
-### Creating a Basic Plugin
-
-```typescript
-import { Plugin } from '@asterflow/plugin'
-
-const myPlugin = Plugin.create({ name: 'my-first-plugin' })
-  .decorate('appName', 'My AsterFlow Application') // Adds a static value to the plugin's context
-  .on('beforeInitialize', (app, context) => {
-    console.log(`Initializing ${context.appName}...`)
-    // app is the AsterFlow instance
-  })
-  .on('afterInitialize', (app, context) => {
-    console.log(`${context.appName} has been initialized!`)
-  })
-
-// This plugin can now be registered with `app.use(myPlugin)`
-```
-
-### Using Configuration and Derivation
-
-Plugins can be configured and can derive values based on their configuration or existing context.
-
-```typescript
+```ts
 import { Plugin } from '@asterflow/plugin'
 
-interface FeaturePluginConfig {
-  featureEnabled: boolean;
-  featureName: string;
-}
-
-const featureTogglePlugin = Plugin.create({ name: 'feature-toggle' })
-  .withConfig<FeaturePluginConfig>({
-    featureEnabled: true,
-    featureName: 'Awesome Feature'
-  })
-  .derive('statusMessage', (context) => {
-    return context.featureEnabled
-      ? `${context.featureName} is enabled.`
-      : `${context.featureName} is disabled.`
-  })
-  .on('beforeInitialize', (app, context) => {
-    console.log(context.statusMessage) // "Awesome Feature is enabled."
-  })
-
-// This plugin can be configured when registered:
-// app.use(featureTogglePlugin, { featureEnabled: false })
+export const fsRoutingPlugin = Plugin.create({ name: 'fs-routing' })
+  .config({ routes: [] as unknown[] })
+  .extends((instance, context) => ({
+    registerRoutes() {
+      for (const route of context.routes) instance.controller(route)
+    }
+  }))
+  .on('beforeInitialize', (instance, context) => instance.registerRoutes())
 ```
 
-### Lifecycle Hooks
+`.decorate()` and `.derive()` build up the plugin's context the same way - `decorate` for a static value, `derive` for one computed from config/context:
 
-Hooks allow plugins to react to important events in the `AsterFlow` lifecycle.
-
-```typescript
-import { Plugin } from '@asterflow/plugin'
-import { Request } from '@asterflow/request'
-import { Response } from '@asterflow/response'
-
-const loggerPlugin = Plugin.create({ name: 'logger-plugin' })
-  .on('onRequest', (request, response, context) => {
-    // Logs request details
-    console.log(`[REQ] ${request.getMethod()} ${request.getPathname()}`)
-  })
-  .on('onResponse', (request, response, context) => {
-    // Logs response details
-    console.log(`[RES] ${response.getStatus()} ${request.getPathname()}`)
-  })
-
-// Register this plugin for global logging
-// app.use(loggerPlugin)
+```ts
+const withGreeting = Plugin.create({ name: 'greeting' })
+  .decorate('appName', 'My App')
+  .derive('greeting', (context) => `Hello, ${context.appName}!`)
+  .on('afterInitialize', (_app, context) => console.log(context.greeting))
 ```
 
-### Integrating with AsterFlow
-
-To use the created plugins, you register them with the `AsterFlow` instance.
-
-```typescript
-import { AsterFlow } from 'asterflow'
-import { adapters } from '@asterflow/adapter'
-import fastify from 'fastify'
-// Import your plugins here
-// import { myPlugin, featureTogglePlugin, loggerPlugin } from './your-plugins'
-
-const server = fastify()
-const app = new AsterFlow({
-  driver: adapters.fastify
-})
-
-// Example plugin registration
-app.use(myPlugin) // No additional configuration
-app.use(featureTogglePlugin, { featureEnabled: false }) // With overridden configuration
-app.use(loggerPlugin)
-
-app.listen(server, { port: 3000 }, (err) => {
-  if (err) {
-    console.error(err)
-    process.exit(1)
-  }
-  console.log('AsterFlow server with plugins listening on port 3000!')
-})
-```
+The finished plugin is registered on an app with `app.use(fsRoutingPlugin, { routes: [...] })`.
 
 ## 🔗 Related Packages
 
--   [asterflow](https://www.npmjs.com/package/asterflow) - The heart of the AsterFlow framework.
--   [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - HTTP adapters for different runtimes.
--   [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - Type-safe routing system.
--   [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - Unified HTTP request system.
--   [@asterflow/response](https://www.npmjs.com/package/@asterflow/response) - Type-safe HTTP response system.
+- Depended on by [asterflow](https://www.npmjs.com/package/asterflow) - the core framework consumes plugin instances and their types to power `app.use()`.
+- Depended on by [@asterflow/multipart](https://www.npmjs.com/package/@asterflow/multipart) - built as a plugin with `Plugin.create()`.
+- Depended on by `@asterflow/fs` - built as a plugin with `Plugin.create()`.
 
 ## 📄 License
 
-MIT - See [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.
+This project is licensed under the [MIT License](../../LICENSE).

package/dist/cjs/index.cjs

@@ -1,34 +1,34 @@
 "use strict";
-var r = Object.defineProperty;
-var f = Object.getOwnPropertyDescriptor;
-var u = Object.getOwnPropertyNames;
+var i = Object.defineProperty;
+var c = Object.getOwnPropertyDescriptor;
+var l = Object.getOwnPropertyNames;
 var d = Object.prototype.hasOwnProperty;
-var g = (o, e) => {
+var f = (t, e) => {
   for (var n in e)
-    r(o, n, { get: e[n], enumerable: !0 });
-}, h = (o, e, n, t) => {
+    i(t, n, { get: e[n], enumerable: !0 });
+}, u = (t, e, n, o) => {
   if (e && typeof e == "object" || typeof e == "function")
-    for (let s of u(e))
-      !d.call(o, s) && s !== n && r(o, s, { get: () => e[s], enumerable: !(t = f(e, s)) || t.enumerable });
-  return o;
+    for (let s of l(e))
+      !d.call(t, s) && s !== n && i(t, s, { get: () => e[s], enumerable: !(o = c(e, s)) || o.enumerable });
+  return t;
 };
-var x = (o) => h(r({}, "__esModule", { value: !0 }), o);
+var g = (t) => u(i({}, "__esModule", { value: !0 }), t);
 // packages/plugin/src/index.ts
-var y = {};
-g(y, {
+var h = {};
+f(h, {
   Plugin: () => a
 });
-module.exports = x(y);
+module.exports = g(h);
 // packages/plugin/src/controllers/Plugin.ts
-var a = class o {
+var a = class t {
   name;
   resolvers;
   defaultConfig;
   hooks = {};
   instance;
   _extensionFn;
-  constructor(e, n, t, s, i) {
-    this.name = e, this.resolvers = n, this.hooks = t, this.defaultConfig = s, this._extensionFn = i;
+  constructor(e, n, o, s, r) {
+    this.name = e, this.resolvers = n, this.hooks = o, this.defaultConfig = s, this._extensionFn = r;
   }
   config(e) {
     return this.defaultConfig = {
@@ -40,32 +40,32 @@ var a = class o {
     return this.instance = e, this;
   }
   decorate(e, n) {
-    let t = async (s, i) => ({
-      ...i,
+    let o = async (s, r) => ({
+      ...r,
       [e]: n
     });
-    return this.resolvers = [...this.resolvers, t], this;
+    return this.resolvers = [...this.resolvers, o], this;
   }
   derive(e, n) {
-    let t = async (s, i) => {
-      let c = { ...i, ...s }, l = await n(c);
+    let o = async (s, r) => {
+      let P = { ...r, ...s }, p = await n(P);
       return {
-        ...i,
-        [e]: l
+        ...r,
+        [e]: p
       };
     };
-    return this.resolvers = [...this.resolvers, t], this;
+    return this.resolvers = [...this.resolvers, o], this;
   }
   on(e, n) {
-    let t = this.hooks[e] || [];
+    let o = this.hooks[e] || [];
     return this.hooks = {
       ...this.hooks,
-      [e]: [...t, n]
+      [e]: [...o, n]
     }, this;
   }
   extends(e) {
     let n = this._extensionFn;
-    return this._extensionFn = (t, s) => ({ ...n ? n(t, s) : {}, ...e(t, s) }), this;
+    return this._extensionFn = (o, s) => ({ ...n ? n(o, s) : {}, ...e(o, s) }), this;
   }
   _build(e) {
     let n = { ...this.defaultConfig, ...e };
@@ -78,7 +78,7 @@ var a = class o {
     };
   }
   static create(e) {
-    return new o(e.name, [], {}, {}, void 0);
+    return new t(e.name, [], {}, {}, void 0);
   }
 };
 0 && (module.exports = {

package/dist/mjs/index.js

@@ -1,13 +1,13 @@
 // packages/plugin/src/controllers/Plugin.ts
-var i = class r {
+var r = class i {
   name;
   resolvers;
   defaultConfig;
   hooks = {};
   instance;
   _extensionFn;
-  constructor(e, n, t, s, o) {
-    this.name = e, this.resolvers = n, this.hooks = t, this.defaultConfig = s, this._extensionFn = o;
+  constructor(e, n, o, s, t) {
+    this.name = e, this.resolvers = n, this.hooks = o, this.defaultConfig = s, this._extensionFn = t;
   }
   config(e) {
     return this.defaultConfig = {
@@ -19,32 +19,32 @@ var i = class r {
     return this.instance = e, this;
   }
   decorate(e, n) {
-    let t = async (s, o) => ({
-      ...o,
+    let o = async (s, t) => ({
+      ...t,
       [e]: n
     });
-    return this.resolvers = [...this.resolvers, t], this;
+    return this.resolvers = [...this.resolvers, o], this;
   }
   derive(e, n) {
-    let t = async (s, o) => {
-      let a = { ...o, ...s }, c = await n(a);
+    let o = async (s, t) => {
+      let a = { ...t, ...s }, P = await n(a);
       return {
-        ...o,
-        [e]: c
+        ...t,
+        [e]: P
       };
     };
-    return this.resolvers = [...this.resolvers, t], this;
+    return this.resolvers = [...this.resolvers, o], this;
   }
   on(e, n) {
-    let t = this.hooks[e] || [];
+    let o = this.hooks[e] || [];
     return this.hooks = {
       ...this.hooks,
-      [e]: [...t, n]
+      [e]: [...o, n]
     }, this;
   }
   extends(e) {
     let n = this._extensionFn;
-    return this._extensionFn = (t, s) => ({ ...n ? n(t, s) : {}, ...e(t, s) }), this;
+    return this._extensionFn = (o, s) => ({ ...n ? n(o, s) : {}, ...e(o, s) }), this;
   }
   _build(e) {
     let n = { ...this.defaultConfig, ...e };
@@ -57,9 +57,9 @@ var i = class r {
     };
   }
   static create(e) {
-    return new r(e.name, [], {}, {}, void 0);
+    return new i(e.name, [], {}, {}, void 0);
   }
 };
 export {
-  i as Plugin
+  r as Plugin
 };

package/dist/types/controllers/Plugin.d.ts

@@ -1,20 +1,22 @@
 import type { AnyAsterflow, ExtendedAsterflow } from 'asterflow';
-import type { PluginHooks, Resolver } from '../types/plugin';
-import type { Prettify, UnionToIntersection } from '../types/utils';
-export declare class Plugin<Path extends string = string, Instance extends AnyAsterflow = AnyAsterflow, Config extends Record<string, any> = {}, Decorate extends Record<string, any> = {}, Derive extends Record<string, any> = {}, Extension extends Record<string, any> = {}> {
-    readonly name: Path;
+import type { DefaultPluginProps, PluginHooks, PluginProps, Resolver } from '../types/plugin';
+import type { MergeProps, Prettify, UnionToIntersection } from '../types/utils';
+export declare class Plugin<const Props extends PluginProps = DefaultPluginProps> {
+    readonly name: Props['path'];
     resolvers: Resolver[];
-    defaultConfig: Partial<Config>;
-    hooks: PluginHooks<any, Decorate, any>;
-    instance: Instance;
+    defaultConfig: Partial<Props['config']>;
+    hooks: PluginHooks<any, Props['decorate'], any>;
+    instance: Props['instance'];
     private _extensionFn?;
     private constructor();
     /**
      * Defines the shape of the configuration and its default values for this plugin.
      */
-    config<C extends Record<string, any>>(defaultConfig: C): Plugin<Path, Instance, Prettify<UnionToIntersection<{
-        defaultConfig: C;
-    } | C | Config>>, Decorate, Derive, Extension>;
+    config<C extends Record<string, any>>(defaultConfig: C): Plugin<MergeProps<Props, {
+        config: Prettify<UnionToIntersection<{
+            defaultConfig: C;
+        } | C | Props["config"]>>;
+    }>>;
     /**
      * O `defineInstance` agora é mais simples. Ele não precisa mais re-tipar
      * a classe inteira. Ele só serve para passar o `this` para o `_build`.
@@ -23,12 +25,16 @@ export declare class Plugin<Path extends string = string, Instance extends AnyAs
     /**
      * Adds a new static value to the plugin's context (decoration).
      */
-    decorate<Key extends string, Value>(key: Key, value: Value): Plugin<Path, Instance, Config, Prettify<UnionToIntersection<Decorate | { [K in Key]: Value; }>>, Derive, Extension>;
+    decorate<Key extends string, Value>(key: Key, value: Value): Plugin<MergeProps<Props, {
+        decorate: Prettify<UnionToIntersection<Props["decorate"] | { [K in Key]: Value; }>>;
+    }>>;
     /**
      * Adds a new property to the context that is derived from the configuration and the existing context.
      * The resolver function is executed lazily when the plugin is registered via `app.use()`.
      */
-    derive<Key extends string, Value>(key: Key, resolverFn: (context: Derive & Config & Decorate) => Value | Promise<Value>): Plugin<Path, Instance, Config, Decorate, Prettify<UnionToIntersection<Derive | { [K in Key]: Awaited<Value>; }>>, Extension>;
+    derive<Key extends string, Value>(key: Key, resolverFn: (context: Props['derive'] & Props['config'] & Props['decorate']) => Value | Promise<Value>): Plugin<MergeProps<Props, {
+        derive: Prettify<UnionToIntersection<Props["derive"] | { [K in Key]: Awaited<Value>; }>>;
+    }>>;
     /**
      * Registers a handler for a specific lifecycle event.
      * Adding a hook makes the plugin "runtime-aware". AsterFlow can optimize by only
@@ -39,21 +45,23 @@ export declare class Plugin<Path extends string = string, Instance extends AnyAs
      *   .on('beforeInitialize', (app, context) => { })
      *   .on('beforeInitialize', (app, context) => { });
      */
-    on<Event extends keyof PluginHooks<ExtendedAsterflow<Instance>, Prettify<UnionToIntersection<Derive | Config | Decorate>>, Extension>>(event: Event, handler: NonNullable<PluginHooks<ExtendedAsterflow<Instance>, Prettify<UnionToIntersection<Derive | Config | Decorate>>, Extension>[Event]>[number]): this;
+    on<Event extends keyof PluginHooks<ExtendedAsterflow<Props['instance']>, Prettify<UnionToIntersection<Props['derive'] | Props['config'] | Props['decorate']>>, Props['extension']>>(event: Event, handler: NonNullable<PluginHooks<ExtendedAsterflow<Props['instance']>, Prettify<UnionToIntersection<Props['derive'] | Props['config'] | Props['decorate']>>, Props['extension']>[Event]>[number]): this;
     /**
      * Defines new properties or methods to be added to the AsterFlow instance.
      * A função recebe a instância do app e o contexto do plugin, e deve retornar um objeto
      * com as novas propriedades.
      */
-    extends<E extends Record<string, any>>(extensionFn: (app: Instance, context: Prettify<UnionToIntersection<Config | Derive | Decorate>>) => E): Plugin<Path, Instance, Config, Decorate, Derive, Prettify<UnionToIntersection<Extension & E>>>;
+    extends<E extends Record<string, any>>(extensionFn: (app: Props['instance'], context: Prettify<UnionToIntersection<Props['config'] | Props['derive'] | Props['decorate']>>) => E): Plugin<MergeProps<Props, {
+        extension: Prettify<UnionToIntersection<Props["extension"] & E>>;
+    }>>;
     /**
      * Builds the final context and hooks from the provided configuration.
      */
     _build(config: any): {
-        name: Path;
-        context: Config & Derive & Decorate;
-        hooks: PluginHooks<any, Decorate, any>;
-        _extensionFn: ((app: Instance, context: Prettify<UnionToIntersection<Config & Decorate & Derive>>) => Extension) | undefined;
+        name: Props["path"];
+        context: Props["config"] & Props["derive"] & Props["decorate"];
+        hooks: PluginHooks<any, Props["decorate"], any>;
+        _extensionFn: ((app: Props["instance"], context: Prettify<UnionToIntersection<Props["config"] & Props["decorate"] & Props["derive"]>>) => Props["extension"]) | undefined;
         resolvers: Resolver[];
     };
     /**
@@ -61,5 +69,12 @@ export declare class Plugin<Path extends string = string, Instance extends AnyAs
      */
     static create<Path extends string, Asterflow extends AnyAsterflow>(options: {
         name: Path;
-    }): Plugin<Path, Asterflow, {}, {}, {}, {}>;
+    }): Plugin<{
+        path: Path;
+        instance: Asterflow;
+        config: {};
+        decorate: {};
+        derive: {};
+        extension: {};
+    }>;
 }

package/dist/types/types/plugin.d.ts

@@ -5,26 +5,43 @@ import type { AnyRouter } from '@asterflow/router';
 import type { AnyAsterflow, ExtendedAsterflow, RouteEntry } from 'asterflow';
 import type { Plugin } from '../controllers/Plugin';
 import type { AnyRecord, UnionToIntersection } from './utils';
+/** `Plugin`'s single generic parameter - the fields it needs to type a plugin. */
+export interface PluginProps {
+    path: string;
+    instance: AnyAsterflow;
+    config: Record<string, any>;
+    decorate: Record<string, any>;
+    derive: Record<string, any>;
+    extension: Record<string, any>;
+}
+export type DefaultPluginProps = {
+    path: string;
+    instance: AnyAsterflow;
+    config: {};
+    decorate: {};
+    derive: {};
+    extension: {};
+};
 export type AnyPluginHooks = PluginHooks<AnyAsterflow, AnyRecord, AnyRecord>;
-export type AnyPlugin = Plugin<string, AnyAsterflow, AnyRecord, AnyRecord, AnyRecord, AnyRecord>;
+export type AnyPlugin = Plugin<any>;
 export type AnyPlugins = Record<string, ResolvedPlugin<AnyPlugin>>;
 export type AnyPluginInstance = ResolvedPlugin<AnyPlugin> & {
     hooks: AnyPluginHooks;
 };
-export type InferPluginExtension<P> = P extends Plugin<any, any, any, any, any, infer Ext> ? Ext : {};
-export type InferPluginContext<P> = P extends Plugin<any, any, infer Config, infer Decorate, infer Derive, any> ? Prettify<UnionToIntersection<Config | Decorate | Derive>> : {};
-export type ResolvedPlugin<P extends Plugin<any, any, any, any, any, any>> = P extends Plugin<infer Path, any, any, infer Ctx, any, infer Ext> ? {
-    name: Path;
-    context: Ctx;
-    hooks: PluginHooks<any, Ctx, Ext>;
-    _extensionFn?: (app: any, context: Ctx) => Ext;
+export type InferPluginExtension<P> = P extends Plugin<infer Props extends PluginProps> ? Props['extension'] : {};
+export type InferPluginContext<P> = P extends Plugin<infer Props extends PluginProps> ? Prettify<UnionToIntersection<Props['config'] | Props['decorate'] | Props['derive']>> : {};
+export type ResolvedPlugin<P extends Plugin<any>> = P extends Plugin<infer Props extends PluginProps> ? {
+    name: Props['path'];
+    context: InferPluginContext<P>;
+    hooks: PluginHooks<any, InferPluginContext<P>, Props['extension']>;
+    _extensionFn?: (app: any, context: InferPluginContext<P>) => Props['extension'];
     resolvers: Resolver[];
 } : never;
 /**
  * Tipo para extrair o objeto de configuração de um plugin.
  * Ele torna as propriedades com valores padrão opcionais.
  */
-export type InferConfigArgument<P extends Plugin<any, any, any, any, any, any>> = P extends Plugin<any, any, infer C, any, any, any> ? Omit<C, keyof P['defaultConfig']> & Partial<Pick<C, keyof P['defaultConfig'] & keyof C>> : never;
+export type InferConfigArgument<P extends Plugin<any>> = P extends Plugin<infer Props extends PluginProps> ? Omit<Props['config'], keyof P['defaultConfig']> & Partial<Pick<Props['config'], keyof P['defaultConfig'] & keyof Props['config']>> : never;
 /**
  * Defines the available lifecycle hooks a plugin can register.
  */

package/dist/types/types/utils.d.ts

@@ -3,3 +3,9 @@ export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) ex
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+/**
+ * Produces a new `Props` object type equal to `Props` with `Patch`'s keys
+ * overridden. Lets a fluent builder method name only the field(s) actually
+ * changing instead of respelling every unchanged generic slot.
+ */
+export type MergeProps<Props, Patch> = Prettify<Omit<Props, keyof Patch> & Patch>;

package/package.json

@@ -1,12 +1,28 @@
 {
   "name": "@asterflow/plugin",
-  "version": "1.0.9",
+  "version": "1.1.0",
+  "description": "The plugin-authoring system used to build AsterFlow plugins - a typed builder for context, config and lifecycle hooks.",
+  "keywords": [
+    "asterflow",
+    "plugin",
+    "plugin-system",
+    "typescript"
+  ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
   "typings": "dist/types/index.d.ts",
   "type": "module",
   "license": "MIT",
+  "author": "Ashu11-A",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AsterFlow/AsterFlow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AsterFlow/AsterFlow/issues"
+  },
+  "homepage": "https://github.com/AsterFlow/AsterFlow",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -18,9 +34,9 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "asterflow": "0.0.5",
-    "@asterflow/response": "1.0.10",
-    "@asterflow/request": "1.0.13"
+    "asterflow": "^1.0.0",
+    "@asterflow/response": "^1.0.10",
+    "@asterflow/request": "^1.0.13"
   },
   "peerDependencies": {
     "typescript": "^5.8.3"