react-chain-of-responsibility 0.0.1-main.9fc4b7d

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 William Wong
+
+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,339 @@
+# `react-chain-of-responsibility`
+
+[Chain of responsibility design pattern](https://refactoring.guru/design-patterns/chain-of-responsibility) for React component customization.
+
+## Background
+
+This package is designed for React component developers to enable component customization via composition using the [chain of responsibility design pattern](https://refactoring.guru/design-patterns/chain-of-responsibility).
+
+Additional entrypoint and hook are provided to use with [Fluent UI as `IRenderFunction`](https://github.com/microsoft/fluentui/blob/master/packages/utilities/src/IRenderFunction.ts).
+
+By composing customizations, they can be decoupled and published separately. App developers could import these published customizations and orchestrate them to their needs. This pattern encourages [separation of concerns](https://en.wikipedia.org/wiki/Separation_of_concerns) and enables economy of customizability.
+
+## Demo
+
+Click here for [our live demo](https://compulim.github.io/react-chain-of-responsibility/).
+
+## How to use
+
+### Using `<Proxy>` component
+
+```jsx
+import { createChainOfResponsibility } from 'react-chain-of-responsibility';
+
+// Creates a <Provider> providing the chain of responsibility service.
+const { Provider, Proxy } = createChainOfResponsibility();
+
+// List of subcomponents.
+const Bold = ({ children }) => <strong>{children}</strong>;
+const Italic = ({ children }) => <i>{children}</i>;
+const Plain = ({ children }) => <>{children}</>;
+
+// Constructs an array of middleware to handle the request and return corresponding subcomponents.
+const middleware = [
+  () => next => request => request === 'bold' ? Bold : next(request),
+  () => next => request => request === 'italic' ? Italic : next(request),
+  () => () => () => Plain
+];
+
+render(
+  <Provider middleware={middleware}>
+    <Proxy request="bold">This is bold.</Proxy>
+    <Proxy request="italic">This is italic.</Proxy>
+    <Proxy>This is plain.</Proxy>
+  </Provider>
+);
+```
+
+This sample will render:
+
+> **This is bold.** _This is italic._ This is plain.
+
+### Using with Fluent UI as `IRenderFunction`
+
+The chain of responsibility design pattern can be used in Fluent UI.
+
+After calling `createChainOfResponsibilityForFluentUI`, it will return `useBuildRenderFunction` hook. This hook, when called, will return a function to use as [`IRenderFunction`](https://github.com/microsoft/fluentui/blob/master/packages/utilities/src/IRenderFunction.ts) in Fluent UI components.
+
+#### Sample code
+
+```jsx
+import { createChainOfResponsibilityForFluentUI } from 'react-chain-of-responsibility';
+
+// Creates a <Provider> providing the chain of responsibility service.
+const { Provider, Proxy } = createChainOfResponsibilityForFluentUI();
+
+// List of subcomponents.
+const Banana = () => <>🍌</>;
+const Orange = () => <>🍊</>;
+
+// Constructs an array of middleware to handle the request and return corresponding subcomponents.
+const middleware = [
+  () => next => props => props?.iconProps?.iconName === 'Banana' ? Banana : next(props),
+  () => next => props => props?.iconProps?.iconName === 'Orange' ? Orange : next(props)
+  // Fallback to `defaultRender` of `IRenderFunction` is automatically injected.
+];
+
+const Inner = () => {
+  const renderIconFunction = useBuildRenderFunction();
+
+  return (
+    <Fragment>
+      <DefaultButton iconProps={{ iconName: 'Banana' }} onRenderIcon={renderIconFunction} />
+      <DefaultButton iconProps={{ iconName: 'Orange' }} onRenderIcon={renderIconFunction} />
+      <DefaultButton iconProps={{ iconName: 'OpenInNewTab' }} onRenderIcon={renderIconFunction} />
+    </Fragment>
+  );
+};
+
+render(
+  <Provider middleware={middleware}>
+    <Inner />
+  </Provider>
+);
+```
+
+There are subtle differences between the standard version and the Fluent UI version:
+
+- Entrypoint is `createChainOfResponsibilityForFluentUI()`
+- Request and props are always of same type
+  - They are optional too, as defined in [`IRenderFunction`](https://github.com/microsoft/fluentui/blob/master/packages/utilities/src/IRenderFunction.ts)
+- Automatic fallback to `defaultRender`
+
+### Decorating UI components
+
+One core feature of chain of responsibility design pattern is allowing middleware to control the execution flow. In other words, middleware can decorate the result of their `next()` middleware. The code snippet below shows how the wrapping could be done.
+
+The bold middleware uses traditional approach to wrap the `next()` result, which is a component named `<Next>`. The italic middleware uses [`react-wrap-with`](https://npmjs.com/package/react-wrap-with/) to simplify the wrapping code.
+
+```jsx
+const middleware = [
+  () => next => request => {
+    const Next = next(request);
+
+    if (request?.has('bold')) {
+      return props => <Bold>{Next && <Next {...props} />}</Bold>;
+    }
+
+    return Next;
+  },
+  () => next => request => wrapWith(request?.has('italic') && Italic)(next(request)),
+  () => () => () => Plain
+];
+
+const App = () => (
+  <Provider middleware={middleware}>
+    <Proxy request={new Set(['bold'])}>This is bold.</Proxy>
+    <Proxy request={new Set(['italic'])}>This is italic.</Proxy>
+    <Proxy request={new Set(['bold', 'italic'])}>This is bold and italic.</Proxy>
+    <Proxy>This is plain.</Proxy>
+  </Provider>
+);
+```
+
+This sample will render:
+
+> **This is bold.** _This is italic._ **_This is bold and italic._** This is plain.
+
+## API
+
+```ts
+function createChainOfResponsibility<Request = undefined, Props = { children?: never }, Init = undefined>(
+  options?: Options
+): {
+  Provider: ComponentType<ProviderProps<Request, Props, Init>>;
+  Proxy: ComponentType<ProxyProps<Request, Props>>;
+  types: {
+    init: Init;
+    middleware: ComponentMiddleware<Request, Props, Init>;
+    props: Props;
+    request: Request;
+  };
+  useBuildComponentCallback: () => UseBuildComponent<Request, Props>;
+};
+```
+
+### Return value
+
+| Name                        | Type                                              | Description                                                                           |
+| --------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `Provider`                  | `React.ComponentType`                             | Entrypoint component, must wraps all usage of customizations                          |
+| `Proxy`                     | `React.ComponentType`                             | Proxy component, process the `request` from props and morph into the result component |
+| `types`                     | `{ init, middleware, props, request }`            | TypeScript: shorthand types, all objects are `undefined` intentionally                |
+| `useBuildComponentCallback` | `() => (request, options) => React.ComponentType` | Callback hook which return a function to build the component for rendering the result |
+
+### Options
+
+```ts
+type Options = {
+  /** Allows a middleware to pass another request object to its next middleware. Default is false. */
+  passModifiedRequest?: boolean;
+};
+```
+
+If `passModifiedRequest` is default or `false`, middleware will not be allowed to pass another reference of `request` object to their `next()` middleware. Instead, the `request` object passed to `next()` will be ignored and the next middleware always receive the original `request` object. This behavior is similar to [ExpressJS](https://expressjs.com/) middleware.
+
+Setting to `true` will enable advanced scenarios and allow a middleware to influence their downstreamers.
+
+When the option is default or `false`, middleware could still modify the `request` object and influence their downstreamers. It is recommended to follow immutable pattern when handling the `request` object, or use deep [`Object.freeze()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze) to guarantee immutability.
+
+### API of `useBuildComponentCallback`
+
+```ts
+type UseBuildComponentCallbackOptions<Props> = { fallbackComponent?: ComponentType<Props> | false | null | undefined };
+
+type UseBuildComponentCallback<Request, Props> = (
+  request: Request,
+  options?: UseBuildComponentCallbackOptions<Props>
+) => ComponentType<Props> | false | null | undefined;
+```
+
+The `fallbackComponent` is a component which all unhandled requests will sink into.
+
+### API for Fluent UI
+
+```ts
+export default function createChainOfResponsibilityForFluentUI<Props extends {}, Init = undefined>(
+  options?: Options
+): ReturnType<typeof createChainOfResponsibility<Props | undefined, Props, Init>> & {
+  useBuildRenderFunction: useBuildRenderFunction<Props>;
+};
+```
+
+#### Return value
+
+| Name                     | Type                                     | Description                                                      |
+| ------------------------ | ---------------------------------------- | ---------------------------------------------------------------- |
+| `useBuildRenderFunction` | `({ getKey }) => IRenderFunction<Props>` | Callback hook to build the `IRenderFunction` to use in Fluent UI |
+
+#### API of `useBuildRenderFunction`
+
+```ts
+type UseBuildRenderFunctionOptions<Props> = { getKey?: (props: Props | undefined) => Key };
+
+type UseBuildRenderFunction<Props> = (options?: UseBuildRenderFunctionOptions<Props>) => IRenderFunction<Props>;
+```
+
+When rendering the element, `getKey` is called to compute the `key` attribute. This is required for some `onRenderXXX` props. These props are usually used to render more than one elements, such as [`DetailsList.onRenderField`](https://developer.microsoft.com/en-us/fluentui#/controls/web/detailslist#implementation), which renders every field (a.k.a. cell) in the [`<DetailsList>`](https://developer.microsoft.com/en-us/fluentui#/controls/web/detailslist).
+
+## Designs
+
+### Why the type of request and props can be different?
+
+This approach may seem overkill at first.
+
+This is to support advanced scenarios where props are not ready until all rendering components are built.
+
+For example, in a chat UI, the middleware is used to influence how the message bubble is rendered, say, a text message vs. an image vs. a hidden message.
+
+The message bubble is responsible to render its timestamp. However, if timestamp grouping is enabled, timestamps in some bubbles will not be rendered if its neighboring bubble render the timestamp. This is also true for avatar grouping.
+
+At component build-time (with the request object), it is not known if a message bubble should render its timestamp or not. This is because we do not know their neighbors yet. At render-time (with props), because all components are prepared, we can start telling each message bubble if they should render their timestamp.
+
+We need to put some logics between build-time and render-time to support grouping. This needs to be a "two-pass" operation because avatar grouping and timestamp grouping look up neighbors in a different direction:
+
+- Avatar grouping look at _predecessors_
+  - If an earlier message already rendered the avatar, it should not render again
+- Timestamp grouping look at _successors_
+  - If a latter message is going to render the timestamp, it should not render it now
+
+### Why the middleware should return component instead of element?
+
+Despite its complexity, there are several advantages when returning component:
+
+- We know if a request would render or not render a request
+  - If it would render, middleware will return a component
+  - If it would not render, middleware will return `false`/`null`/`undefined`
+- Components works with hooks in a more natural way
+- Build-time and render-time are separated to support advanced scenarios
+
+### Why we call the handler "middleware"?
+
+"Handler" is often seen in articles explaining the chain of responsibility design pattern. They are typically written in a language-agnostic format, such as pseudo code.
+
+However, "middleware" is a more popular word in JavaScript community. Thus, we chose "middleware".
+
+### Why we need to call `createChainOfResponsibility()` to create `<Provider>`?
+
+This is for supporting multiple providers/proxies under a single app/tree.
+
+### Why we disable `passModifiedRequest` by default?
+
+To reduce learning curve and likelihood of bugs, we disabled this feature until developers are more proficient with this package.
+
+If the `request` object passed to `next()` differs from the original `request` object, a reminder will be logged in the console.
+
+## Behaviors
+
+### `<Proxy>` vs. `useBuildComponentCallback`
+
+Most of the time, use `<Proxy>`.
+
+Behind the scene, `<Proxy>` call `useBuildComponentCallback()` to build the component it would morph into.
+
+You can use the following decision tree to know when to use `<Proxy>` vs. `useBuildComponentCallback`
+
+- If you want to know what component will render before actual render happen, use `useBuildComponentCallback()`
+  - For example, using `useBuildComponentCallback()` allow you to know if the middleware will skip rendering the request
+- If your component use `request` prop which is conflict with `<Proxy>`, use `useBuildComponentCallback()`
+- Otherwise, use `<Proxy>`
+
+### Calling `next()` multiple times
+
+It is possible to call `next()` multiple times to render multiple copies of UI. Middleware should be written as a stateless function.
+
+This is best used with options `passModifiedRequest` set to `true`. This combination allow a middleware to render the UI multiple times with some variations, such as rendering content and minimap at the same time.
+
+### Calling `next()` later
+
+This is not supported.
+
+This is because React does not allow asynchronous render. An exception will be thrown if the `next()` is called after return.
+
+### Good middleware is stateless
+
+When writing middleware, keep them as stateless as possible and do not relies on data outside of the `request` object. The way it is writing should be similar to React function components.
+
+### Good middleware returns false to skip rendering
+
+If the middleware wants to skip rendering a request, return `false`/`null`/`undefined` directly. Do not return `() => false`, `<Fragment />`, or any other invisible components.
+
+This helps the component which send the request to the chain of responsibility to determine whether the request could be rendered or not.
+
+### Typing a component which expect no props to be passed
+
+To type a component which expects no props to be passed, use `ComponentType<{ children?: undefined }>`.
+
+In TypeScript, `{}` literally means any objects. Components of type `ComponentType<{}>` means [anything can be passed as props](https://www.typescriptlang.org/play?#code/C4TwDgpgBACgTgezAZygXigbwL4G4BQ+AxggHbLBRiIoBcsNqGmUyCAthMABYCWpAc3oByCABtkEYVDz4gA).
+
+Although `Record<any, never>` means empty object, it is not extensible. Thus, [`Record<any, never> & { className: string }` means `Record<any, never>`](https://www.typescriptlang.org/play?#code/C4TwDgpgBACgTgezAZygXigJQgYwXAEwB4BDAOxABooyIA3COAPgG4AoUSKAZQFcAjeElQYhKKADIoAbyg4ANiWTIAciQC2EAFxRkwOAEsyAcygBfdmzxk9UMIhQ6+ghyJlzFytZp0BydSRGvubsQA).
+
+We believe the best way to type a component which does not allow any props, is `ComponentType<{ children?: undefined }>`.
+
+## Inspirations
+
+This package is heavily inspired by [Redux](https://redux.js.org/) middleware, especially [`applyMiddleware()`](https://github.com/reduxjs/redux/blob/master/docs/api/applyMiddleware.md) and [`compose()`](https://github.com/reduxjs/redux/blob/master/docs/api/compose.md). We read [this article](https://medium.com/@jacobp100/you-arent-using-redux-middleware-enough-94ffe991e6) to understand the concept, followed by some more readings on functional programming topics.
+
+Over multiple years, the chain of responsibility design pattern is proven to be very flexible and extensible in [Bot Framework Web Chat](https://github.co/microsoft/BotFramework-WebChat/). Internal parts of Web Chat is written as middleware consumed by itself. Multiple bundles with various sizes can be offered by removing some middleware and treeshaking them off.
+
+Middleware and router in [ExpressJS](https://expressjs.com/) also inspired us to learn more about this pattern. Their fallback middleware always returns 404 is an innovative approach.
+
+[Bing chat](https://bing.com/chat/) helped us understand and experiment with different naming.
+
+### Differences from Redux and ExpressJS
+
+The chain of responsibility design pattern implemented in [Redux](https://redux.js.org/) and [ExpressJS](https://expressjs.com/) prefers fire-and-forget execution (a.k.a. unidirectional): the result from the last middleware will not bubble up back to the first middleware. Instead, the caller may only collect the result from the last middleware. Sometimes, middleware may interrupt the execution and never return any results.
+
+However, the chain of responsibility design pattern implemented in this package prefers call-and-return execution: the result from the last middleware will propagate back to the first middleware before returning to the caller. This gives every middleware a chance to manipulate the result from downstreamers before sending it back.
+
+## Plain English
+
+This package implements the _chain of responsibility_ design pattern. Based on _request_, the chain of responsibility will be asked to _build a React component_. The middleware will _form a chain_ and request is _passed to the first one in the chain_. If the chain decided to render it, a component will be returned, otherwise, `false`/`null`/`undefined`.
+
+## Contributions
+
+Like us? [Star](https://github.com/compulim/react-chain-of-responsibility/stargazers) us.
+
+Want to make it better? [File](https://github.com/compulim/react-chain-of-responsibility/issues) us an issue.
+
+Don't like something you see? [Submit](https://github.com/compulim/react-chain-of-responsibility/pulls) a pull request.

package/lib/commonjs/createChainOfResponsibility.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createChainOfResponsibility;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/typeof"));
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+var _some = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/some"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _reverse = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reverse"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _react = _interopRequireWildcard(require("react"));
+var _applyMiddleware = _interopRequireDefault(require("./private/applyMiddleware"));
+var _excluded = ["children", "fallbackComponent", "request"];
+function createChainOfResponsibility() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var context = /*#__PURE__*/(0, _react.createContext)({
+    get useBuildComponentCallback() {
+      throw new Error('useBuildComponentCallback() hook cannot be used outside of its corresponding <Provider>');
+    }
+  });
+  var Provider = function Provider(_ref) {
+    var _context;
+    var children = _ref.children,
+      init = _ref.init,
+      middleware = _ref.middleware;
+    if (!(0, _isArray.default)(middleware) || (0, _some.default)(middleware).call(middleware, function (middleware) {
+      return typeof middleware !== 'function';
+    })) {
+      throw new Error('middleware prop must be an array of functions');
+    }
+    var patchedMiddleware = (0, _map.default)(_context = middleware || []).call(_context, function (fn) {
+      return function (init) {
+        var enhancer = fn(init);
+        return function (next) {
+          return function (originalRequest) {
+            // False positive: although we did not re-assign the variable from true, it was initialized as undefined.
+            // eslint-disable-next-line prefer-const
+            var hasReturned;
+            var returnValue = enhancer(function (nextRequest) {
+              if (hasReturned) {
+                throw new Error('next() cannot be called after the function had returned synchronously');
+              }
+              !options.passModifiedRequest && nextRequest !== originalRequest && console.warn('react-chain-of-responsibility: "options.passModifiedRequest" must be set to true to pass a different request object to next().');
+              return next(options.passModifiedRequest ? nextRequest : originalRequest);
+            })(originalRequest);
+            hasReturned = true;
+            if ( /*#__PURE__*/(0, _react.isValidElement)(returnValue)) {
+              throw new Error('middleware must not return React element directly');
+            } else if (returnValue !== false && returnValue !== null && typeof returnValue !== 'function' && typeof returnValue !== 'undefined' &&
+            // There are no definitive ways to check if an object is a React component or not.
+            // We are checking if the object has a render function (classic component).
+            // Note: "forwardRef()" returns plain object, not class instance.
+            !((0, _typeof2.default)(returnValue) === 'object' && typeof returnValue['render'] === 'function')) {
+              throw new Error('middleware must return false, null, undefined, function component, or class component');
+            }
+            return returnValue;
+          };
+        };
+      };
+    });
+    var enhancer = (0, _react.useMemo)(function () {
+      var _context2;
+      return (
+        // We are reversing because it is easier to read:
+        // - With reverse, [a, b, c] will become a(b(c(fn)))
+        // - Without reverse, [a, b, c] will become c(b(a(fn)))
+        _applyMiddleware.default.apply(void 0, (0, _toConsumableArray2.default)((0, _reverse.default)(_context2 = (0, _toConsumableArray2.default)(patchedMiddleware || [])).call(_context2)))(init)
+      );
+    }, [init, middleware]);
+    var useBuildComponentCallback = (0, _react.useCallback)(function (request) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return enhancer(function () {
+        return options.fallbackComponent;
+      })(request);
+    }, [enhancer]);
+    var contextValue = (0, _react.useMemo)(function () {
+      return {
+        useBuildComponentCallback: useBuildComponentCallback
+      };
+    }, [useBuildComponentCallback]);
+    return /*#__PURE__*/_react.default.createElement(context.Provider, {
+      value: contextValue
+    }, children);
+  };
+  Provider.defaultProps = {};
+  Provider.displayName = 'ChainOfResponsibilityProvider';
+  Provider.propTypes = {
+    children: _propTypes.default.any,
+    init: _propTypes.default.any,
+    middleware: _propTypes.default.any
+  };
+  var useBuildComponentCallback = function useBuildComponentCallback() {
+    return (0, _react.useContext)(context).useBuildComponentCallback;
+  };
+  var Proxy = /*#__PURE__*/(0, _react.memo)(
+  // False positive: "children" is not a prop.
+  // eslint-disable-next-line react/prop-types
+  function (_ref2) {
+    var children = _ref2.children,
+      fallbackComponent = _ref2.fallbackComponent,
+      request = _ref2.request,
+      props = (0, _objectWithoutProperties2.default)(_ref2, _excluded);
+    var enhancer;
+    try {
+      enhancer = useBuildComponentCallback();
+    } catch (_unused) {
+      throw new Error('<Proxy> cannot be used outside of its corresponding <Provider>');
+    }
+    var Component = enhancer(request, {
+      fallbackComponent: fallbackComponent
+    });
+    return Component ? /*#__PURE__*/_react.default.createElement(Component, props, children) : null;
+  });
+  Proxy.defaultProps = {};
+  Proxy.displayName = 'Proxy';
+  Proxy.propTypes = {
+    fallbackComponent: _propTypes.default.any,
+    request: _propTypes.default.any
+  };
+  return {
+    Provider: Provider,
+    Proxy: Proxy,
+    types: {
+      init: undefined,
+      middleware: undefined,
+      props: undefined,
+      request: undefined
+    },
+    useBuildComponentCallback: useBuildComponentCallback
+  };
+}
+//# sourceMappingURL=createChainOfResponsibility.js.map

package/lib/commonjs/createChainOfResponsibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChainOfResponsibility.js","names":["_propTypes","_interopRequireDefault","require","_react","_interopRequireWildcard","_applyMiddleware","_excluded","createChainOfResponsibility","options","arguments","length","undefined","context","createContext","useBuildComponentCallback","Error","Provider","_ref","_context","children","init","middleware","_isArray","default","_some","call","patchedMiddleware","_map","fn","enhancer","next","originalRequest","hasReturned","returnValue","nextRequest","passModifiedRequest","console","warn","isValidElement","_typeof2","useMemo","_context2","applyMiddleware","apply","_toConsumableArray2","_reverse","useCallback","request","fallbackComponent","contextValue","createElement","value","defaultProps","displayName","propTypes","PropTypes","any","useContext","Proxy","memo","_ref2","props","_objectWithoutProperties2","_unused","Component","types"],"sources":["../../src/createChainOfResponsibility.tsx"],"sourcesContent":["import PropTypes from 'prop-types';\nimport React, { ComponentType, createContext, isValidElement, memo, useCallback, useContext, useMemo } from 'react';\n\nimport applyMiddleware from './private/applyMiddleware';\n\nimport type { ComponentMiddleware } from './types';\nimport type { PropsWithChildren } from 'react';\n\ntype UseBuildComponentCallbackOptions<Props> = { fallbackComponent?: ComponentType<Props> | false | null | undefined };\n\ntype UseBuildComponentCallback<Request, Props> = (\n  request: Request,\n  options?: UseBuildComponentCallbackOptions<Props>\n) => ComponentType<Props> | false | null | undefined;\n\ntype ProviderContext<Request, Props> = {\n  useBuildComponentCallback: UseBuildComponentCallback<Request, Props>;\n};\n\ntype ProviderProps<Request, Props, Init> = PropsWithChildren<{\n  middleware: ComponentMiddleware<Request, Props, Init>[];\n}> &\n  (Init extends never | undefined ? { init?: Init } : { init: Init });\n\ntype ProxyProps<Request, Props> = Request extends never | undefined\n  ? Props & { fallbackComponent?: ComponentType<Props>; request?: Request }\n  : Props & { fallbackComponent?: ComponentType<Props>; request: Request };\n\ntype Options = {\n  /**\n   * Allows a middleware to pass another request object when calling its next middleware. Default is false.\n   *\n   * However, middleware could modify the request object before calling its next middleware. It is recommended\n   * to use Object.freeze() to prevent middleware from modifying the request object.\n   */\n  passModifiedRequest?: boolean;\n};\n\nexport default function createChainOfResponsibility<\n  Request = undefined,\n  Props = { children?: never },\n  Init = undefined\n>(\n  options: Options = {}\n): {\n  Provider: ComponentType<ProviderProps<Request, Props, Init>>;\n  Proxy: ComponentType<ProxyProps<Request, Props>>;\n  types: {\n    init: Init;\n    middleware: ComponentMiddleware<Request, Props, Init>;\n    props: Props;\n    request: Request;\n  };\n  useBuildComponentCallback: () => UseBuildComponentCallback<Request, Props>;\n} {\n  const context = createContext<ProviderContext<Request, Props>>({\n    get useBuildComponentCallback(): ProviderContext<Request, Props>['useBuildComponentCallback'] {\n      throw new Error('useBuildComponentCallback() hook cannot be used outside of its corresponding <Provider>');\n    }\n  });\n\n  const Provider: ComponentType<ProviderProps<Request, Props, Init>> = ({ children, init, middleware }) => {\n    if (!Array.isArray(middleware) || middleware.some(middleware => typeof middleware !== 'function')) {\n      throw new Error('middleware prop must be an array of functions');\n    }\n\n    const patchedMiddleware: ComponentMiddleware<Request, Props, Init>[] = (middleware || []).map(fn => {\n      return init => {\n        const enhancer = fn(init);\n\n        return next => originalRequest => {\n          // False positive: although we did not re-assign the variable from true, it was initialized as undefined.\n          // eslint-disable-next-line prefer-const\n          let hasReturned: boolean;\n\n          const returnValue = enhancer(nextRequest => {\n            if (hasReturned) {\n              throw new Error('next() cannot be called after the function had returned synchronously');\n            }\n\n            !options.passModifiedRequest &&\n              nextRequest !== originalRequest &&\n              console.warn(\n                'react-chain-of-responsibility: \"options.passModifiedRequest\" must be set to true to pass a different request object to next().'\n              );\n\n            return next(options.passModifiedRequest ? nextRequest : originalRequest);\n          })(originalRequest);\n\n          hasReturned = true;\n\n          if (isValidElement(returnValue)) {\n            throw new Error('middleware must not return React element directly');\n          } else if (\n            returnValue !== false &&\n            returnValue !== null &&\n            typeof returnValue !== 'function' &&\n            typeof returnValue !== 'undefined' &&\n            // There are no definitive ways to check if an object is a React component or not.\n            // We are checking if the object has a render function (classic component).\n            // Note: \"forwardRef()\" returns plain object, not class instance.\n            !(typeof returnValue === 'object' && typeof returnValue['render'] === 'function')\n          ) {\n            throw new Error('middleware must return false, null, undefined, function component, or class component');\n          }\n\n          return returnValue;\n        };\n      };\n    });\n\n    const enhancer = useMemo(\n      () =>\n        // We are reversing because it is easier to read:\n        // - With reverse, [a, b, c] will become a(b(c(fn)))\n        // - Without reverse, [a, b, c] will become c(b(a(fn)))\n        applyMiddleware<[Request], ComponentType<Props> | false | null | undefined, [Init]>(\n          ...[...(patchedMiddleware || [])].reverse()\n        )(init as Init),\n      [init, middleware]\n    );\n\n    const useBuildComponentCallback = useCallback<UseBuildComponentCallback<Request, Props>>(\n      (request, options = {}) => enhancer(() => options.fallbackComponent)(request),\n      [enhancer]\n    );\n\n    const contextValue = useMemo<ProviderContext<Request, Props>>(\n      () => ({ useBuildComponentCallback }),\n      [useBuildComponentCallback]\n    );\n\n    return <context.Provider value={contextValue}>{children}</context.Provider>;\n  };\n\n  Provider.defaultProps = {};\n  Provider.displayName = 'ChainOfResponsibilityProvider';\n  Provider.propTypes = {\n    children: PropTypes.any,\n    init: PropTypes.any,\n    middleware: PropTypes.any\n  };\n\n  const useBuildComponentCallback = () => useContext(context).useBuildComponentCallback;\n\n  const Proxy: ComponentType<ProxyProps<Request, Props>> = memo(\n    // False positive: \"children\" is not a prop.\n    // eslint-disable-next-line react/prop-types\n    ({ children, fallbackComponent, request, ...props }) => {\n      let enhancer: ReturnType<typeof useBuildComponentCallback>;\n\n      try {\n        enhancer = useBuildComponentCallback();\n      } catch {\n        throw new Error('<Proxy> cannot be used outside of its corresponding <Provider>');\n      }\n\n      const Component = enhancer(request as Request, { fallbackComponent });\n\n      return Component ? <Component {...(props as Props)}>{children}</Component> : null;\n    }\n  );\n\n  Proxy.defaultProps = {};\n  Proxy.displayName = 'Proxy';\n  Proxy.propTypes = {\n    fallbackComponent: PropTypes.any,\n    request: PropTypes.any\n  };\n\n  return {\n    Provider,\n    Proxy,\n    types: {\n      init: undefined as unknown as Init,\n      middleware: undefined as unknown as ComponentMiddleware<Request, Props, Init>,\n      props: undefined as unknown as Props,\n      request: undefined as unknown as Request\n    },\n    useBuildComponentCallback\n  };\n}\n"],"mappings":"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"}

package/lib/commonjs/createChainOfResponsibilityForFluentUI.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createChainOfResponsibilityForFluentUI;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/objectSpread2"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+var _react = _interopRequireWildcard(require("react"));
+var _createChainOfResponsibility = _interopRequireDefault(require("./createChainOfResponsibility"));
+// We are using the props as both "Request" and "Props".
+// This should eases migration from `onRender` to chain of responsibility.
+// Downside is, web developers could accidentally pass request as props and not honoring props modified by upstreamers.
+function createChainOfResponsibilityForFluentUI(options) {
+  var returnValue = (0, _createChainOfResponsibility.default)(options);
+  var Proxy = returnValue.Proxy;
+  var useBuildRenderFunction = function useBuildRenderFunction() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var getKey = options.getKey;
+    return (0, _react.useCallback)(function (props, defaultRender) {
+      return /*#__PURE__*/_react.default.createElement(Proxy, (0, _extends2.default)({}, props, {
+        fallbackComponent: defaultRender,
+        key: getKey === null || getKey === void 0 ? void 0 : getKey(props),
+        request: props
+      }));
+    }, [getKey]);
+  };
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, returnValue), {}, {
+    useBuildRenderFunction: useBuildRenderFunction
+  });
+}
+//# sourceMappingURL=createChainOfResponsibilityForFluentUI.js.map

package/lib/commonjs/createChainOfResponsibilityForFluentUI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChainOfResponsibilityForFluentUI.js","names":["_react","_interopRequireWildcard","require","_createChainOfResponsibility","_interopRequireDefault","createChainOfResponsibilityForFluentUI","options","returnValue","createChainOfResponsibility","Proxy","useBuildRenderFunction","arguments","length","undefined","getKey","useCallback","props","defaultRender","default","createElement","_extends2","fallbackComponent","key","request","_objectSpread2"],"sources":["../../src/createChainOfResponsibilityForFluentUI.tsx"],"sourcesContent":["import React, { useCallback } from 'react';\n\nimport createChainOfResponsibility from './createChainOfResponsibility';\n\nimport type { IRenderFunction } from '@fluentui/react';\nimport type { Key } from 'react';\n\ntype UseBuildRenderFunctionOptions<Props> = { getKey?: (props: Props | undefined) => Key };\n\ntype UseBuildRenderFunction<Props> = (options?: UseBuildRenderFunctionOptions<Props>) => IRenderFunction<Props>;\n\n// We are using the props as both \"Request\" and \"Props\".\n// This should eases migration from `onRender` to chain of responsibility.\n// Downside is, web developers could accidentally pass request as props and not honoring props modified by upstreamers.\nexport default function createChainOfResponsibilityForFluentUI<Props extends object, Init = undefined>(\n  options?: Parameters<typeof createChainOfResponsibility>[0]\n): ReturnType<typeof createChainOfResponsibility<Props | undefined, Props, Init>> & {\n  useBuildRenderFunction: UseBuildRenderFunction<Props>;\n} {\n  const returnValue = createChainOfResponsibility<Props | undefined, Props, Init>(options);\n\n  const { Proxy } = returnValue;\n\n  const useBuildRenderFunction: UseBuildRenderFunction<Props> = (options = {}) => {\n    const { getKey } = options;\n\n    return useCallback<IRenderFunction<Props>>(\n      (props, defaultRender) => (\n        <Proxy {...(props as Props)} fallbackComponent={defaultRender} key={getKey?.(props)} request={props} />\n      ),\n      [getKey]\n    );\n  };\n\n  return { ...returnValue, useBuildRenderFunction };\n}\n"],"mappings":";;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AAEA,IAAAC,4BAAA,GAAAC,sBAAA,CAAAF,OAAA;AASA;AACA;AACA;AACe,SAASG,sCAAsCA,CAC5DC,OAA2D,EAG3D;EACA,IAAMC,WAAW,GAAG,IAAAC,oCAA2B,EAAiCF,OAAO,CAAC;EAExF,IAAQG,KAAK,GAAKF,WAAW,CAArBE,KAAK;EAEb,IAAMC,sBAAqD,GAAG,SAAxDA,sBAAqDA,CAAA,EAAqB;IAAA,IAAjBJ,OAAO,GAAAK,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IACzE,IAAQG,MAAM,GAAKR,OAAO,CAAlBQ,MAAM;IAEd,OAAO,IAAAC,kBAAW,EAChB,UAACC,KAAK,EAAEC,aAAa;MAAA,oBACnBjB,MAAA,CAAAkB,OAAA,CAAAC,aAAA,CAACV,KAAK,MAAAW,SAAA,CAAAF,OAAA,MAAMF,KAAK;QAAYK,iBAAiB,EAAEJ,aAAc;QAACK,GAAG,EAAER,MAAM,aAANA,MAAM,uBAANA,MAAM,CAAGE,KAAK,CAAE;QAACO,OAAO,EAAEP;MAAM,GAAG;IAAA,CACxG,EACD,CAACF,MAAM,CAAC,CACT;EACH,CAAC;EAED,WAAAU,cAAA,CAAAN,OAAA,MAAAM,cAAA,CAAAN,OAAA,MAAYX,WAAW;IAAEG,sBAAsB,EAAtBA;EAAsB;AACjD"}

package/lib/commonjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+_Object$defineProperty(exports, "createChainOfResponsibility", {
+  enumerable: true,
+  get: function get() {
+    return _createChainOfResponsibility.default;
+  }
+});
+_Object$defineProperty(exports, "createChainOfResponsibilityForFluentUI", {
+  enumerable: true,
+  get: function get() {
+    return _createChainOfResponsibilityForFluentUI.default;
+  }
+});
+var _createChainOfResponsibility = _interopRequireDefault(require("./createChainOfResponsibility"));
+var _createChainOfResponsibilityForFluentUI = _interopRequireDefault(require("./createChainOfResponsibilityForFluentUI"));
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_createChainOfResponsibility","_interopRequireDefault","require","_createChainOfResponsibilityForFluentUI"],"sources":["../../src/index.ts"],"sourcesContent":["import createChainOfResponsibility from './createChainOfResponsibility';\nimport createChainOfResponsibilityForFluentUI from './createChainOfResponsibilityForFluentUI';\n\nimport type { ComponentMiddleware } from './types';\n\nexport { createChainOfResponsibility, createChainOfResponsibilityForFluentUI };\n\nexport type { ComponentMiddleware };\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,IAAAA,4BAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,uCAAA,GAAAF,sBAAA,CAAAC,OAAA"}

package/lib/commonjs/private/applyMiddleware.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = applyMiddleware;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/toConsumableArray"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _compose = _interopRequireDefault(require("./compose"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function applyMiddleware() {
+  for (var _len = arguments.length, arrayOfMiddleware = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrayOfMiddleware[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _len2 = arguments.length, init = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      init[_key2] = arguments[_key2];
+    }
+    var chain = (0, _map.default)(arrayOfMiddleware).call(arrayOfMiddleware, function (middleware) {
+      return middleware.apply(void 0, init);
+    });
+    return _compose.default.apply(void 0, (0, _toConsumableArray2.default)(chain));
+  };
+}
+//# sourceMappingURL=applyMiddleware.js.map

package/lib/commonjs/private/applyMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyMiddleware.js","names":["_compose","_interopRequireDefault","require","applyMiddleware","_len","arguments","length","arrayOfMiddleware","Array","_key","_len2","init","_key2","chain","_map","default","call","middleware","apply","compose","_toConsumableArray2"],"sources":["../../../src/private/applyMiddleware.ts"],"sourcesContent":["import compose from './compose';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Fn<P extends any[], R> = (...args: P) => R;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Middleware<P extends any[], R, S extends any[]> = (...init: S) => Enhancer<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function applyMiddleware<P extends any[], R, S extends any[]>(\n  ...arrayOfMiddleware: Middleware<P, R, S>[]\n) {\n  return (...init: S) => {\n    const chain = arrayOfMiddleware.map(middleware => middleware(...init));\n\n    return compose(...chain);\n  };\n}\n"],"mappings":";;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,sBAAA,CAAAC,OAAA;AAWA;AACe,SAASC,eAAeA,CAAA,EAErC;EAAA,SAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,EADGC,iBAAiB,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;IAAjBF,iBAAiB,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;EAAA;EAEpB,OAAO,YAAgB;IAAA,SAAAC,KAAA,GAAAL,SAAA,CAAAC,MAAA,EAAZK,IAAI,OAAAH,KAAA,CAAAE,KAAA,GAAAE,KAAA,MAAAA,KAAA,GAAAF,KAAA,EAAAE,KAAA;MAAJD,IAAI,CAAAC,KAAA,IAAAP,SAAA,CAAAO,KAAA;IAAA;IACb,IAAMC,KAAK,GAAG,IAAAC,IAAA,CAAAC,OAAA,EAAAR,iBAAiB,EAAAS,IAAA,CAAjBT,iBAAiB,EAAK,UAAAU,UAAU;MAAA,OAAIA,UAAU,CAAAC,KAAA,SAAIP,IAAI,CAAC;IAAA,EAAC;IAEtE,OAAOQ,gBAAO,CAAAD,KAAA,aAAAE,mBAAA,CAAAL,OAAA,EAAIF,KAAK,EAAC;EAC1B,CAAC;AACH"}

package/lib/commonjs/private/compose.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = compose;
+var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function compose() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function (fn) {
+    return (0, _reduce.default)(fns).call(fns, function (chain, fn) {
+      return fn(chain);
+    }, fn);
+  };
+}
+//# sourceMappingURL=compose.js.map

package/lib/commonjs/private/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","names":["compose","_len","arguments","length","fns","Array","_key","fn","_reduce","default","call","chain"],"sources":["../../../src/private/compose.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Fn<P extends any[], R> = (...args: P) => R;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function compose<P extends any[], R>(...fns: Enhancer<P, R>[]): Enhancer<P, R> {\n  return (fn: Fn<P, R>): Fn<P, R> => fns.reduce((chain, fn) => fn(chain), fn);\n}\n"],"mappings":";;;;;;;;;AAAA;;AAGA;;AAGA;AACe,SAASA,OAAOA,CAAA,EAA+D;EAAA,SAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAvCC,GAAG,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;IAAHF,GAAG,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;EAAA;EACxD,OAAO,UAACC,EAAY;IAAA,OAAe,IAAAC,OAAA,CAAAC,OAAA,EAAAL,GAAG,EAAAM,IAAA,CAAHN,GAAG,EAAQ,UAACO,KAAK,EAAEJ,EAAE;MAAA,OAAKA,EAAE,CAACI,KAAK,CAAC;IAAA,GAAEJ,EAAE,CAAC;EAAA;AAC7E"}

package/lib/commonjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/commonjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["import type { ComponentType } from 'react';\nimport type { Middleware } from './private/applyMiddleware';\n\nexport type ComponentMiddleware<Request, Props = { children?: never }, Init = undefined> = Middleware<\n  [Request],\n  ComponentType<Props> | false | null | undefined,\n  [Init]\n>;\n"],"mappings":""}

package/lib/esmodules/createChainOfResponsibility.js

@@ -0,0 +1,130 @@
+import _objectWithoutProperties from "@babel/runtime-corejs3/helpers/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
+import _typeof from "@babel/runtime-corejs3/helpers/typeof";
+var _excluded = ["children", "fallbackComponent", "request"];
+import _Array$isArray from "@babel/runtime-corejs3/core-js-stable/array/is-array";
+import _someInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/some";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import _reverseInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reverse";
+import PropTypes from 'prop-types';
+import React, { createContext, isValidElement, memo, useCallback, useContext, useMemo } from 'react';
+import applyMiddleware from './private/applyMiddleware';
+export default function createChainOfResponsibility() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var context = /*#__PURE__*/createContext({
+    get useBuildComponentCallback() {
+      throw new Error('useBuildComponentCallback() hook cannot be used outside of its corresponding <Provider>');
+    }
+  });
+  var Provider = function Provider(_ref) {
+    var _context;
+    var children = _ref.children,
+      init = _ref.init,
+      middleware = _ref.middleware;
+    if (!_Array$isArray(middleware) || _someInstanceProperty(middleware).call(middleware, function (middleware) {
+      return typeof middleware !== 'function';
+    })) {
+      throw new Error('middleware prop must be an array of functions');
+    }
+    var patchedMiddleware = _mapInstanceProperty(_context = middleware || []).call(_context, function (fn) {
+      return function (init) {
+        var enhancer = fn(init);
+        return function (next) {
+          return function (originalRequest) {
+            // False positive: although we did not re-assign the variable from true, it was initialized as undefined.
+            // eslint-disable-next-line prefer-const
+            var hasReturned;
+            var returnValue = enhancer(function (nextRequest) {
+              if (hasReturned) {
+                throw new Error('next() cannot be called after the function had returned synchronously');
+              }
+              !options.passModifiedRequest && nextRequest !== originalRequest && console.warn('react-chain-of-responsibility: "options.passModifiedRequest" must be set to true to pass a different request object to next().');
+              return next(options.passModifiedRequest ? nextRequest : originalRequest);
+            })(originalRequest);
+            hasReturned = true;
+            if ( /*#__PURE__*/isValidElement(returnValue)) {
+              throw new Error('middleware must not return React element directly');
+            } else if (returnValue !== false && returnValue !== null && typeof returnValue !== 'function' && typeof returnValue !== 'undefined' &&
+            // There are no definitive ways to check if an object is a React component or not.
+            // We are checking if the object has a render function (classic component).
+            // Note: "forwardRef()" returns plain object, not class instance.
+            !(_typeof(returnValue) === 'object' && typeof returnValue['render'] === 'function')) {
+              throw new Error('middleware must return false, null, undefined, function component, or class component');
+            }
+            return returnValue;
+          };
+        };
+      };
+    });
+    var enhancer = useMemo(function () {
+      var _context2;
+      return (
+        // We are reversing because it is easier to read:
+        // - With reverse, [a, b, c] will become a(b(c(fn)))
+        // - Without reverse, [a, b, c] will become c(b(a(fn)))
+        applyMiddleware.apply(void 0, _toConsumableArray(_reverseInstanceProperty(_context2 = _toConsumableArray(patchedMiddleware || [])).call(_context2)))(init)
+      );
+    }, [init, middleware]);
+    var useBuildComponentCallback = useCallback(function (request) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return enhancer(function () {
+        return options.fallbackComponent;
+      })(request);
+    }, [enhancer]);
+    var contextValue = useMemo(function () {
+      return {
+        useBuildComponentCallback: useBuildComponentCallback
+      };
+    }, [useBuildComponentCallback]);
+    return /*#__PURE__*/React.createElement(context.Provider, {
+      value: contextValue
+    }, children);
+  };
+  Provider.defaultProps = {};
+  Provider.displayName = 'ChainOfResponsibilityProvider';
+  Provider.propTypes = {
+    children: PropTypes.any,
+    init: PropTypes.any,
+    middleware: PropTypes.any
+  };
+  var useBuildComponentCallback = function useBuildComponentCallback() {
+    return useContext(context).useBuildComponentCallback;
+  };
+  var Proxy = /*#__PURE__*/memo(
+  // False positive: "children" is not a prop.
+  // eslint-disable-next-line react/prop-types
+  function (_ref2) {
+    var children = _ref2.children,
+      fallbackComponent = _ref2.fallbackComponent,
+      request = _ref2.request,
+      props = _objectWithoutProperties(_ref2, _excluded);
+    var enhancer;
+    try {
+      enhancer = useBuildComponentCallback();
+    } catch (_unused) {
+      throw new Error('<Proxy> cannot be used outside of its corresponding <Provider>');
+    }
+    var Component = enhancer(request, {
+      fallbackComponent: fallbackComponent
+    });
+    return Component ? /*#__PURE__*/React.createElement(Component, props, children) : null;
+  });
+  Proxy.defaultProps = {};
+  Proxy.displayName = 'Proxy';
+  Proxy.propTypes = {
+    fallbackComponent: PropTypes.any,
+    request: PropTypes.any
+  };
+  return {
+    Provider: Provider,
+    Proxy: Proxy,
+    types: {
+      init: undefined,
+      middleware: undefined,
+      props: undefined,
+      request: undefined
+    },
+    useBuildComponentCallback: useBuildComponentCallback
+  };
+}
+//# sourceMappingURL=createChainOfResponsibility.js.map

package/lib/esmodules/createChainOfResponsibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChainOfResponsibility.js","names":["PropTypes","React","createContext","isValidElement","memo","useCallback","useContext","useMemo","applyMiddleware","createChainOfResponsibility","options","arguments","length","undefined","context","useBuildComponentCallback","Error","Provider","_ref","_context","children","init","middleware","_Array$isArray","_someInstanceProperty","call","patchedMiddleware","_mapInstanceProperty","fn","enhancer","next","originalRequest","hasReturned","returnValue","nextRequest","passModifiedRequest","console","warn","_typeof","_context2","apply","_toConsumableArray","_reverseInstanceProperty","request","fallbackComponent","contextValue","createElement","value","defaultProps","displayName","propTypes","any","Proxy","_ref2","props","_objectWithoutProperties","_excluded","_unused","Component","types"],"sources":["../../src/createChainOfResponsibility.tsx"],"sourcesContent":["import PropTypes from 'prop-types';\nimport React, { ComponentType, createContext, isValidElement, memo, useCallback, useContext, useMemo } from 'react';\n\nimport applyMiddleware from './private/applyMiddleware';\n\nimport type { ComponentMiddleware } from './types';\nimport type { PropsWithChildren } from 'react';\n\ntype UseBuildComponentCallbackOptions<Props> = { fallbackComponent?: ComponentType<Props> | false | null | undefined };\n\ntype UseBuildComponentCallback<Request, Props> = (\n  request: Request,\n  options?: UseBuildComponentCallbackOptions<Props>\n) => ComponentType<Props> | false | null | undefined;\n\ntype ProviderContext<Request, Props> = {\n  useBuildComponentCallback: UseBuildComponentCallback<Request, Props>;\n};\n\ntype ProviderProps<Request, Props, Init> = PropsWithChildren<{\n  middleware: ComponentMiddleware<Request, Props, Init>[];\n}> &\n  (Init extends never | undefined ? { init?: Init } : { init: Init });\n\ntype ProxyProps<Request, Props> = Request extends never | undefined\n  ? Props & { fallbackComponent?: ComponentType<Props>; request?: Request }\n  : Props & { fallbackComponent?: ComponentType<Props>; request: Request };\n\ntype Options = {\n  /**\n   * Allows a middleware to pass another request object when calling its next middleware. Default is false.\n   *\n   * However, middleware could modify the request object before calling its next middleware. It is recommended\n   * to use Object.freeze() to prevent middleware from modifying the request object.\n   */\n  passModifiedRequest?: boolean;\n};\n\nexport default function createChainOfResponsibility<\n  Request = undefined,\n  Props = { children?: never },\n  Init = undefined\n>(\n  options: Options = {}\n): {\n  Provider: ComponentType<ProviderProps<Request, Props, Init>>;\n  Proxy: ComponentType<ProxyProps<Request, Props>>;\n  types: {\n    init: Init;\n    middleware: ComponentMiddleware<Request, Props, Init>;\n    props: Props;\n    request: Request;\n  };\n  useBuildComponentCallback: () => UseBuildComponentCallback<Request, Props>;\n} {\n  const context = createContext<ProviderContext<Request, Props>>({\n    get useBuildComponentCallback(): ProviderContext<Request, Props>['useBuildComponentCallback'] {\n      throw new Error('useBuildComponentCallback() hook cannot be used outside of its corresponding <Provider>');\n    }\n  });\n\n  const Provider: ComponentType<ProviderProps<Request, Props, Init>> = ({ children, init, middleware }) => {\n    if (!Array.isArray(middleware) || middleware.some(middleware => typeof middleware !== 'function')) {\n      throw new Error('middleware prop must be an array of functions');\n    }\n\n    const patchedMiddleware: ComponentMiddleware<Request, Props, Init>[] = (middleware || []).map(fn => {\n      return init => {\n        const enhancer = fn(init);\n\n        return next => originalRequest => {\n          // False positive: although we did not re-assign the variable from true, it was initialized as undefined.\n          // eslint-disable-next-line prefer-const\n          let hasReturned: boolean;\n\n          const returnValue = enhancer(nextRequest => {\n            if (hasReturned) {\n              throw new Error('next() cannot be called after the function had returned synchronously');\n            }\n\n            !options.passModifiedRequest &&\n              nextRequest !== originalRequest &&\n              console.warn(\n                'react-chain-of-responsibility: \"options.passModifiedRequest\" must be set to true to pass a different request object to next().'\n              );\n\n            return next(options.passModifiedRequest ? nextRequest : originalRequest);\n          })(originalRequest);\n\n          hasReturned = true;\n\n          if (isValidElement(returnValue)) {\n            throw new Error('middleware must not return React element directly');\n          } else if (\n            returnValue !== false &&\n            returnValue !== null &&\n            typeof returnValue !== 'function' &&\n            typeof returnValue !== 'undefined' &&\n            // There are no definitive ways to check if an object is a React component or not.\n            // We are checking if the object has a render function (classic component).\n            // Note: \"forwardRef()\" returns plain object, not class instance.\n            !(typeof returnValue === 'object' && typeof returnValue['render'] === 'function')\n          ) {\n            throw new Error('middleware must return false, null, undefined, function component, or class component');\n          }\n\n          return returnValue;\n        };\n      };\n    });\n\n    const enhancer = useMemo(\n      () =>\n        // We are reversing because it is easier to read:\n        // - With reverse, [a, b, c] will become a(b(c(fn)))\n        // - Without reverse, [a, b, c] will become c(b(a(fn)))\n        applyMiddleware<[Request], ComponentType<Props> | false | null | undefined, [Init]>(\n          ...[...(patchedMiddleware || [])].reverse()\n        )(init as Init),\n      [init, middleware]\n    );\n\n    const useBuildComponentCallback = useCallback<UseBuildComponentCallback<Request, Props>>(\n      (request, options = {}) => enhancer(() => options.fallbackComponent)(request),\n      [enhancer]\n    );\n\n    const contextValue = useMemo<ProviderContext<Request, Props>>(\n      () => ({ useBuildComponentCallback }),\n      [useBuildComponentCallback]\n    );\n\n    return <context.Provider value={contextValue}>{children}</context.Provider>;\n  };\n\n  Provider.defaultProps = {};\n  Provider.displayName = 'ChainOfResponsibilityProvider';\n  Provider.propTypes = {\n    children: PropTypes.any,\n    init: PropTypes.any,\n    middleware: PropTypes.any\n  };\n\n  const useBuildComponentCallback = () => useContext(context).useBuildComponentCallback;\n\n  const Proxy: ComponentType<ProxyProps<Request, Props>> = memo(\n    // False positive: \"children\" is not a prop.\n    // eslint-disable-next-line react/prop-types\n    ({ children, fallbackComponent, request, ...props }) => {\n      let enhancer: ReturnType<typeof useBuildComponentCallback>;\n\n      try {\n        enhancer = useBuildComponentCallback();\n      } catch {\n        throw new Error('<Proxy> cannot be used outside of its corresponding <Provider>');\n      }\n\n      const Component = enhancer(request as Request, { fallbackComponent });\n\n      return Component ? <Component {...(props as Props)}>{children}</Component> : null;\n    }\n  );\n\n  Proxy.defaultProps = {};\n  Proxy.displayName = 'Proxy';\n  Proxy.propTypes = {\n    fallbackComponent: PropTypes.any,\n    request: PropTypes.any\n  };\n\n  return {\n    Provider,\n    Proxy,\n    types: {\n      init: undefined as unknown as Init,\n      middleware: undefined as unknown as ComponentMiddleware<Request, Props, Init>,\n      props: undefined as unknown as Props,\n      request: undefined as unknown as Request\n    },\n    useBuildComponentCallback\n  };\n}\n"],"mappings":"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"}

package/lib/esmodules/createChainOfResponsibilityForFluentUI.js

@@ -0,0 +1,26 @@
+import _objectSpread from "@babel/runtime-corejs3/helpers/objectSpread2";
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import React, { useCallback } from 'react';
+import createChainOfResponsibility from './createChainOfResponsibility';
+// We are using the props as both "Request" and "Props".
+// This should eases migration from `onRender` to chain of responsibility.
+// Downside is, web developers could accidentally pass request as props and not honoring props modified by upstreamers.
+export default function createChainOfResponsibilityForFluentUI(options) {
+  var returnValue = createChainOfResponsibility(options);
+  var Proxy = returnValue.Proxy;
+  var useBuildRenderFunction = function useBuildRenderFunction() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var getKey = options.getKey;
+    return useCallback(function (props, defaultRender) {
+      return /*#__PURE__*/React.createElement(Proxy, _extends({}, props, {
+        fallbackComponent: defaultRender,
+        key: getKey === null || getKey === void 0 ? void 0 : getKey(props),
+        request: props
+      }));
+    }, [getKey]);
+  };
+  return _objectSpread(_objectSpread({}, returnValue), {}, {
+    useBuildRenderFunction: useBuildRenderFunction
+  });
+}
+//# sourceMappingURL=createChainOfResponsibilityForFluentUI.js.map

package/lib/esmodules/createChainOfResponsibilityForFluentUI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChainOfResponsibilityForFluentUI.js","names":["React","useCallback","createChainOfResponsibility","createChainOfResponsibilityForFluentUI","options","returnValue","Proxy","useBuildRenderFunction","arguments","length","undefined","getKey","props","defaultRender","createElement","_extends","fallbackComponent","key","request","_objectSpread"],"sources":["../../src/createChainOfResponsibilityForFluentUI.tsx"],"sourcesContent":["import React, { useCallback } from 'react';\n\nimport createChainOfResponsibility from './createChainOfResponsibility';\n\nimport type { IRenderFunction } from '@fluentui/react';\nimport type { Key } from 'react';\n\ntype UseBuildRenderFunctionOptions<Props> = { getKey?: (props: Props | undefined) => Key };\n\ntype UseBuildRenderFunction<Props> = (options?: UseBuildRenderFunctionOptions<Props>) => IRenderFunction<Props>;\n\n// We are using the props as both \"Request\" and \"Props\".\n// This should eases migration from `onRender` to chain of responsibility.\n// Downside is, web developers could accidentally pass request as props and not honoring props modified by upstreamers.\nexport default function createChainOfResponsibilityForFluentUI<Props extends object, Init = undefined>(\n  options?: Parameters<typeof createChainOfResponsibility>[0]\n): ReturnType<typeof createChainOfResponsibility<Props | undefined, Props, Init>> & {\n  useBuildRenderFunction: UseBuildRenderFunction<Props>;\n} {\n  const returnValue = createChainOfResponsibility<Props | undefined, Props, Init>(options);\n\n  const { Proxy } = returnValue;\n\n  const useBuildRenderFunction: UseBuildRenderFunction<Props> = (options = {}) => {\n    const { getKey } = options;\n\n    return useCallback<IRenderFunction<Props>>(\n      (props, defaultRender) => (\n        <Proxy {...(props as Props)} fallbackComponent={defaultRender} key={getKey?.(props)} request={props} />\n      ),\n      [getKey]\n    );\n  };\n\n  return { ...returnValue, useBuildRenderFunction };\n}\n"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,WAAW,QAAQ,OAAO;AAE1C,OAAOC,2BAA2B,MAAM,+BAA+B;AASvE;AACA;AACA;AACA,eAAe,SAASC,sCAAsCA,CAC5DC,OAA2D,EAG3D;EACA,IAAMC,WAAW,GAAGH,2BAA2B,CAAiCE,OAAO,CAAC;EAExF,IAAQE,KAAK,GAAKD,WAAW,CAArBC,KAAK;EAEb,IAAMC,sBAAqD,GAAG,SAAxDA,sBAAqDA,CAAA,EAAqB;IAAA,IAAjBH,OAAO,GAAAI,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IACzE,IAAQG,MAAM,GAAKP,OAAO,CAAlBO,MAAM;IAEd,OAAOV,WAAW,CAChB,UAACW,KAAK,EAAEC,aAAa;MAAA,oBACnBb,KAAA,CAAAc,aAAA,CAACR,KAAK,EAAAS,QAAA,KAAMH,KAAK;QAAYI,iBAAiB,EAAEH,aAAc;QAACI,GAAG,EAAEN,MAAM,aAANA,MAAM,uBAANA,MAAM,CAAGC,KAAK,CAAE;QAACM,OAAO,EAAEN;MAAM,GAAG;IAAA,CACxG,EACD,CAACD,MAAM,CAAC,CACT;EACH,CAAC;EAED,OAAAQ,aAAA,CAAAA,aAAA,KAAYd,WAAW;IAAEE,sBAAsB,EAAtBA;EAAsB;AACjD"}

package/lib/esmodules/index.js

@@ -0,0 +1,4 @@
+import createChainOfResponsibility from './createChainOfResponsibility';
+import createChainOfResponsibilityForFluentUI from './createChainOfResponsibilityForFluentUI';
+export { createChainOfResponsibility, createChainOfResponsibilityForFluentUI };
+//# sourceMappingURL=index.js.map

package/lib/esmodules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createChainOfResponsibility","createChainOfResponsibilityForFluentUI"],"sources":["../../src/index.ts"],"sourcesContent":["import createChainOfResponsibility from './createChainOfResponsibility';\nimport createChainOfResponsibilityForFluentUI from './createChainOfResponsibilityForFluentUI';\n\nimport type { ComponentMiddleware } from './types';\n\nexport { createChainOfResponsibility, createChainOfResponsibilityForFluentUI };\n\nexport type { ComponentMiddleware };\n"],"mappings":"AAAA,OAAOA,2BAA2B,MAAM,+BAA+B;AACvE,OAAOC,sCAAsC,MAAM,0CAA0C;AAI7F,SAASD,2BAA2B,EAAEC,sCAAsC"}

package/lib/esmodules/private/applyMiddleware.js

@@ -0,0 +1,22 @@
+import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import compose from './compose';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function applyMiddleware() {
+  for (var _len = arguments.length, arrayOfMiddleware = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrayOfMiddleware[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _len2 = arguments.length, init = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      init[_key2] = arguments[_key2];
+    }
+    var chain = _mapInstanceProperty(arrayOfMiddleware).call(arrayOfMiddleware, function (middleware) {
+      return middleware.apply(void 0, init);
+    });
+    return compose.apply(void 0, _toConsumableArray(chain));
+  };
+}
+//# sourceMappingURL=applyMiddleware.js.map

package/lib/esmodules/private/applyMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyMiddleware.js","names":["compose","applyMiddleware","_len","arguments","length","arrayOfMiddleware","Array","_key","_len2","init","_key2","chain","_mapInstanceProperty","call","middleware","apply","_toConsumableArray"],"sources":["../../../src/private/applyMiddleware.ts"],"sourcesContent":["import compose from './compose';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Fn<P extends any[], R> = (...args: P) => R;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Middleware<P extends any[], R, S extends any[]> = (...init: S) => Enhancer<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function applyMiddleware<P extends any[], R, S extends any[]>(\n  ...arrayOfMiddleware: Middleware<P, R, S>[]\n) {\n  return (...init: S) => {\n    const chain = arrayOfMiddleware.map(middleware => middleware(...init));\n\n    return compose(...chain);\n  };\n}\n"],"mappings":";;AAAA,OAAOA,OAAO,MAAM,WAAW;;AAE/B;;AASA;AACA,eAAe,SAASC,eAAeA,CAAA,EAErC;EAAA,SAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,EADGC,iBAAiB,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;IAAjBF,iBAAiB,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;EAAA;EAEpB,OAAO,YAAgB;IAAA,SAAAC,KAAA,GAAAL,SAAA,CAAAC,MAAA,EAAZK,IAAI,OAAAH,KAAA,CAAAE,KAAA,GAAAE,KAAA,MAAAA,KAAA,GAAAF,KAAA,EAAAE,KAAA;MAAJD,IAAI,CAAAC,KAAA,IAAAP,SAAA,CAAAO,KAAA;IAAA;IACb,IAAMC,KAAK,GAAGC,oBAAA,CAAAP,iBAAiB,EAAAQ,IAAA,CAAjBR,iBAAiB,EAAK,UAAAS,UAAU;MAAA,OAAIA,UAAU,CAAAC,KAAA,SAAIN,IAAI,CAAC;IAAA,EAAC;IAEtE,OAAOT,OAAO,CAAAe,KAAA,SAAAC,kBAAA,CAAIL,KAAK,EAAC;EAC1B,CAAC;AACH"}

package/lib/esmodules/private/compose.js

@@ -0,0 +1,17 @@
+import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function compose() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function (fn) {
+    return _reduceInstanceProperty(fns).call(fns, function (chain, fn) {
+      return fn(chain);
+    }, fn);
+  };
+}
+//# sourceMappingURL=compose.js.map

package/lib/esmodules/private/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","names":["compose","_len","arguments","length","fns","Array","_key","fn","_reduceInstanceProperty","call","chain"],"sources":["../../../src/private/compose.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Fn<P extends any[], R> = (...args: P) => R;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function compose<P extends any[], R>(...fns: Enhancer<P, R>[]): Enhancer<P, R> {\n  return (fn: Fn<P, R>): Fn<P, R> => fns.reduce((chain, fn) => fn(chain), fn);\n}\n"],"mappings":";AAAA;;AAGA;;AAGA;AACA,eAAe,SAASA,OAAOA,CAAA,EAA+D;EAAA,SAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAvCC,GAAG,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;IAAHF,GAAG,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;EAAA;EACxD,OAAO,UAACC,EAAY;IAAA,OAAeC,uBAAA,CAAAJ,GAAG,EAAAK,IAAA,CAAHL,GAAG,EAAQ,UAACM,KAAK,EAAEH,EAAE;MAAA,OAAKA,EAAE,CAACG,KAAK,CAAC;IAAA,GAAEH,EAAE,CAAC;EAAA;AAC7E"}

package/lib/esmodules/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esmodules/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["import type { ComponentType } from 'react';\nimport type { Middleware } from './private/applyMiddleware';\n\nexport type ComponentMiddleware<Request, Props = { children?: never }, Init = undefined> = Middleware<\n  [Request],\n  ComponentType<Props> | false | null | undefined,\n  [Init]\n>;\n"],"mappings":""}

package/lib/types/createChainOfResponsibility.d.ts

@@ -0,0 +1,44 @@
+import { ComponentType } from 'react';
+import type { ComponentMiddleware } from './types';
+import type { PropsWithChildren } from 'react';
+type UseBuildComponentCallbackOptions<Props> = {
+    fallbackComponent?: ComponentType<Props> | false | null | undefined;
+};
+type UseBuildComponentCallback<Request, Props> = (request: Request, options?: UseBuildComponentCallbackOptions<Props>) => ComponentType<Props> | false | null | undefined;
+type ProviderProps<Request, Props, Init> = PropsWithChildren<{
+    middleware: ComponentMiddleware<Request, Props, Init>[];
+}> & (Init extends never | undefined ? {
+    init?: Init;
+} : {
+    init: Init;
+});
+type ProxyProps<Request, Props> = Request extends never | undefined ? Props & {
+    fallbackComponent?: ComponentType<Props>;
+    request?: Request;
+} : Props & {
+    fallbackComponent?: ComponentType<Props>;
+    request: Request;
+};
+type Options = {
+    /**
+     * Allows a middleware to pass another request object when calling its next middleware. Default is false.
+     *
+     * However, middleware could modify the request object before calling its next middleware. It is recommended
+     * to use Object.freeze() to prevent middleware from modifying the request object.
+     */
+    passModifiedRequest?: boolean;
+};
+export default function createChainOfResponsibility<Request = undefined, Props = {
+    children?: never;
+}, Init = undefined>(options?: Options): {
+    Provider: ComponentType<ProviderProps<Request, Props, Init>>;
+    Proxy: ComponentType<ProxyProps<Request, Props>>;
+    types: {
+        init: Init;
+        middleware: ComponentMiddleware<Request, Props, Init>;
+        props: Props;
+        request: Request;
+    };
+    useBuildComponentCallback: () => UseBuildComponentCallback<Request, Props>;
+};
+export {};

package/lib/types/createChainOfResponsibilityForFluentUI.d.ts

@@ -0,0 +1,11 @@
+import createChainOfResponsibility from './createChainOfResponsibility';
+import type { IRenderFunction } from '@fluentui/react';
+import type { Key } from 'react';
+type UseBuildRenderFunctionOptions<Props> = {
+    getKey?: (props: Props | undefined) => Key;
+};
+type UseBuildRenderFunction<Props> = (options?: UseBuildRenderFunctionOptions<Props>) => IRenderFunction<Props>;
+export default function createChainOfResponsibilityForFluentUI<Props extends object, Init = undefined>(options?: Parameters<typeof createChainOfResponsibility>[0]): ReturnType<typeof createChainOfResponsibility<Props | undefined, Props, Init>> & {
+    useBuildRenderFunction: UseBuildRenderFunction<Props>;
+};
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,5 @@
+import createChainOfResponsibility from './createChainOfResponsibility';
+import createChainOfResponsibilityForFluentUI from './createChainOfResponsibilityForFluentUI';
+import type { ComponentMiddleware } from './types';
+export { createChainOfResponsibility, createChainOfResponsibilityForFluentUI };
+export type { ComponentMiddleware };

package/lib/types/private/applyMiddleware.d.ts

@@ -0,0 +1,5 @@
+type Fn<P extends any[], R> = (...args: P) => R;
+export type Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;
+export type Middleware<P extends any[], R, S extends any[]> = (...init: S) => Enhancer<P, R>;
+export default function applyMiddleware<P extends any[], R, S extends any[]>(...arrayOfMiddleware: Middleware<P, R, S>[]): (...init: S) => (next: (...args: P) => R) => (...args: P) => R;
+export {};

package/lib/types/private/compose.d.ts

@@ -0,0 +1,4 @@
+type Fn<P extends any[], R> = (...args: P) => R;
+type Enhancer<P extends any[], R> = (next: Fn<P, R>) => Fn<P, R>;
+export default function compose<P extends any[], R>(...fns: Enhancer<P, R>[]): Enhancer<P, R>;
+export {};

package/lib/types/types.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentType } from 'react';
+import type { Middleware } from './private/applyMiddleware';
+export type ComponentMiddleware<Request, Props = {
+    children?: never;
+}, Init = undefined> = Middleware<[
+    Request
+], ComponentType<Props> | false | null | undefined, [
+    Init
+]>;

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "react-chain-of-responsibility",
+  "version": "0.0.1-main.9fc4b7d",
+  "description": "Using chain of responsibility design pattern for React component customization.",
+  "files": [
+    "./lib/*"
+  ],
+  "exports": {
+    ".": {
+      "import": "./lib/esmodules/index.js",
+      "require": "./lib/commonjs/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./createChainOfResponsibility": {
+      "import": "./lib/esmodules/createChainOfResponsibility.js",
+      "require": "./lib/commonjs/createChainOfResponsibility.js",
+      "types": "./lib/types/createChainOfResponsibility.d.ts"
+    },
+    "./createChainOfResponsibilityForFluentUI": {
+      "import": "./lib/esmodules/createChainOfResponsibilityForFluentUI.js",
+      "require": "./lib/commonjs/createChainOfResponsibilityForFluentUI.js",
+      "types": "./lib/types/createChainOfResponsibilityForFluentUI.d.ts"
+    }
+  },
+  "main": "./lib/commonjs/index.js",
+  "typings": "./lib/types/index.d.ts",
+  "scripts": {
+    "build": "npm run build:babel && npm run build:typescript",
+    "build:babel": "npm run build:babel:commonjs && npm run build:babel:esmodules",
+    "build:babel:commonjs": "babel src --config-file ./babel.commonjs.config.json --extensions .ts,.tsx --out-dir ./lib/commonjs/",
+    "build:babel:esmodules": "babel src --config-file ./babel.esmodules.config.json --extensions .ts,.tsx --out-dir ./lib/esmodules/",
+    "build:typescript": "tsc --project ./src/tsconfig.declaration.json",
+    "bump": "npm run bump:prod && npm run bump:dev && npm run bump:auditfix && npm run bump:babel",
+    "bump:auditfix": "npm audit fix || exit 0",
+    "bump:babel": "npm run bump:babel:commonjs && npm run bump:babel:esmodules",
+    "bump:babel:commonjs": "cat babel.commonjs.config.json | jq --arg CORE_JS_VERSION `cat node_modules/@babel/runtime-corejs3/package.json | jq -r .version` '(.plugins[] | select(.[0] == \"@babel/plugin-transform-runtime\"))[1].version = $CORE_JS_VERSION' | prettier --parser json > babel.commonjs.config.json.tmp && mv babel.commonjs.config.json.tmp babel.commonjs.config.json",
+    "bump:babel:esmodules": "cat babel.esmodules.config.json | jq --arg CORE_JS_VERSION `cat node_modules/@babel/runtime-corejs3/package.json | jq -r .version` '(.plugins[] | select(.[0] == \"@babel/plugin-transform-runtime\"))[1].version = $CORE_JS_VERSION' | prettier --parser json > babel.esmodules.config.json.tmp && mv babel.esmodules.config.json.tmp babel.esmodules.config.json",
+    "bump:babel:jest": "cat babel.jest.config.json | jq --arg CORE_JS_VERSION `cat node_modules/@babel/runtime-corejs3/package.json | jq -r .version` '(.plugins[] | select(.[0] == \"@babel/plugin-transform-runtime\"))[1].version = $CORE_JS_VERSION' | prettier --parser json > babel.jest.config.json.tmp && mv babel.jest.config.json.tmp babel.jest.config.json",
+    "bump:dev": "if [ `cat package.json | jq -r '(.devDependencies // {}) | length'` -ne 0 ]; then npm install $(cat package.json | jq -r '(.pinDependencies // {}) as $p | ((.devDependencies // {}) | keys) | map(. + \"@\" + ($p[.] // [\"latest\"])[0]) | .[]'); fi",
+    "bump:prod": "if [ `cat package.json | jq -r '(.dependencies // {}) | length'` -ne 0 ]; then npm install --save-exact $(cat package.json | jq -r '(.pinDependencies // {}) as $p | ((.dependencies // {}) | keys) | map(. + \"@\" + ($p[.] // [\"latest\"])[0]) | .[]'); fi",
+    "postbump": "cat package.json | jq '. + (.dependencies = (((.dependencies // {}) + (.localPeerDependencies // {})) | to_entries | sort_by(.key) | from_entries)) | (.devDependencies = (((.devDependencies // {}) + (.localPeerDevDependencies // {})) | to_entries | sort_by(.key) | from_entries))' > package-temp.json && mv package-temp.json package.json",
+    "prebump": "cat package.json | jq '(((.localPeerDependencies // {}) | keys | map([\"dependencies\", .])) + ((.localPeerDevDependencies // {}) | keys | map([\"devDependencies\", .]))) as $localPeerPaths | delpaths($localPeerPaths)' > package-temp.json && mv package-temp.json package.json",
+    "precommit": "eslint ./src/",
+    "prepack": "cp ../../CHANGELOG.md . && cp ../../LICENSE . && cp ../../README.md .",
+    "start": "esbuild --bundle --outfile=./public/main.js --servedir=./public --sourcemap ./scenarios/index.jsx",
+    "jest": "jest",
+    "test": "npm run test:jest && npm run test:typescript",
+    "test:jest": "npm run jest",
+    "test:typescript": "tsc --project ./src/tsconfig.test.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/compulim/react-chain-of-responsibility.git"
+  },
+  "keywords": [
+    "react",
+    "react-hook",
+    "react-hooks"
+  ],
+  "author": "William Wong (https://github.com/compulim)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/compulim/react-chain-of-responsibility/issues"
+  },
+  "homepage": "https://github.com/compulim/react-chain-of-responsibility#readme",
+  "pinDependencies": {
+    "@testing-library/react": [
+      "12",
+      "@testing-library/react-hooks@8.0.1 does not support react@>=18"
+    ],
+    "@types/react": [
+      "17",
+      "@testing-library/react-hooks@8.0.1 does not support react@>=18"
+    ],
+    "react": [
+      "17",
+      "@testing-library/react-hooks@8.0.1 does not support react@>=18"
+    ],
+    "react-dom": [
+      "17",
+      "@testing-library/react-hooks@8.0.1 does not support react@>=18"
+    ],
+    "react-test-renderer": [
+      "17",
+      "@testing-library/react-hooks@8.0.1 does not support react@>=18"
+    ]
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.0",
+    "@babel/plugin-transform-runtime": "^7.21.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-react": "^7.18.6",
+    "@babel/preset-typescript": "^7.21.0",
+    "@fluentui/react": "^8.106.7",
+    "@testing-library/react": "^12.1.5",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@types/jest": "^29.4.0",
+    "@types/node": "^18.14.0",
+    "@types/react": "^17.0.53",
+    "esbuild": "^0.17.10",
+    "jest": "^29.4.3",
+    "jest-environment-jsdom": "^29.4.3",
+    "prettier": "^2.8.4",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "react-test-renderer": "^17.0.2",
+    "react-wrap-with": "0.0.2-main.fa6cc79",
+    "typescript": "^4.9.5"
+  },
+  "peerDependencies": {
+    "react": ">=16.9.0"
+  },
+  "dependencies": {
+    "@babel/runtime-corejs3": "7.21.0",
+    "prop-types": "^15.8.1"
+  }
+}