@webiny/react-composition 6.0.0-beta.0 → 6.0.0-rc.1

package/Compose.d.ts

@@ -1,8 +1,9 @@
-import { DecoratableTypes } from "./Context";
-import { ComposeWith } from "./types";
+import React from "react";
+import type { DecoratableTypes } from "./Context.js";
+import type { ComposeWith } from "./types.js";
 export interface ComposeProps {
     function?: DecoratableTypes;
     component?: DecoratableTypes;
     with: ComposeWith;
 }
-export declare const Compose: (props: ComposeProps) => null;
+export declare const Compose: (props: ComposeProps) => React.JSX.Element | null;

package/Compose.js

@@ -1,26 +1,68 @@
-"use strict";
+import React, { useEffect, useRef } from "react";
+import { useCompositionStore } from "./Context.js";
+import { useCompositionScope } from "./CompositionScope.js";
+export const Compose = props => {
+  const store = useCompositionStore();
+  const {
+    scope,
+    inherit
+  } = useCompositionScope();
+  const targetFn = props.function ?? props.component;
+  if (!targetFn) {
+    console.warn("You must provide a function or a component to compose with!", props);
+    return null;
+  }
+  if (typeof targetFn.original === "undefined") {
+    console.warn(`You must make your function "${targetFn.originalName ?? targetFn.name}" composable, by using the makeDecoratable() function!`);
+    return null;
+  }
+  const decorators = Array.isArray(props.with) ? props.with : [props.with];
+  const currentScope = scope[scope.length - 1] ?? "*";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Compose = void 0;
-var _react = require("react");
-var _Context = require("./Context");
-var _CompositionScope = require("./CompositionScope");
-var Compose = exports.Compose = function Compose(props) {
-  var _useComposition = (0, _Context.useComposition)(),
-    composeComponent = _useComposition.composeComponent;
-  var scope = (0, _CompositionScope.useCompositionScope)();
-  var targetFn = props.function ?? props.component;
-  (0, _react.useEffect)(function () {
-    if (typeof targetFn.original === "undefined") {
-      console.warn("You must make your function \"".concat(targetFn.originalName ?? targetFn.name, "\" composable, by using the makeDecoratable() function!"));
-      return;
+  // Register synchronously during render so decorators are available immediately.
+  // Pass silent=true to avoid notifying listeners mid-render (which would trigger
+  // setState in other components and cause React warnings).
+  store.register(targetFn.original, decorators, currentScope, inherit, true);
+  return /*#__PURE__*/React.createElement(ComposeEffects, {
+    store: store,
+    target: targetFn.original,
+    decorators: decorators,
+    scope: currentScope
+  });
+};
+
+/**
+ * Separate component for the effect to avoid re-running the cleanup on every render.
+ * This component handles cleanup on unmount and when props change.
+ */
+function ComposeEffects({
+  store,
+  target,
+  decorators,
+  scope
+}) {
+  const prevRef = useRef(null);
+  useEffect(() => {
+    const prev = prevRef.current;
+
+    // On prop change: unregister old decorators.
+    if (prev && (prev.decorators !== decorators || prev.scope !== scope)) {
+      store.unregister(target, prev.decorators, prev.scope);
+      // Re-register new ones (they were already registered during render,
+      // but the idempotency check handles this).
+      store.register(target, decorators, scope);
     }
-    var decorators = Array.isArray(props.with) ? props.with : [props.with];
-    return composeComponent(targetFn.original, decorators, scope);
-  }, [props.with]);
+    prevRef.current = {
+      decorators,
+      scope
+    };
+
+    // Cleanup on unmount.
+    return () => {
+      store.unregister(target, decorators, scope);
+    };
+  }, [store, target, decorators, scope]);
   return null;
-};
+}
 
 //# sourceMappingURL=Compose.js.map

package/Compose.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_Context","_CompositionScope","Compose","exports","props","_useComposition","useComposition","composeComponent","scope","useCompositionScope","targetFn","function","component","useEffect","original","console","warn","concat","originalName","name","decorators","Array","isArray","with"],"sources":["Compose.tsx"],"sourcesContent":["import { useEffect } from \"react\";\nimport { DecoratableTypes, useComposition } from \"./Context\";\nimport { useCompositionScope } from \"~/CompositionScope\";\nimport { ComposeWith, Decoratable, Enumerable } from \"./types\";\n\nexport interface ComposeProps {\n    function?: DecoratableTypes;\n    component?: DecoratableTypes;\n    with: ComposeWith;\n}\n\nexport const Compose = (props: ComposeProps) => {\n    const { composeComponent } = useComposition();\n    const scope = useCompositionScope();\n\n    const targetFn = (props.function ?? props.component) as Decoratable;\n\n    useEffect(() => {\n        if (typeof targetFn.original === \"undefined\") {\n            console.warn(\n                `You must make your function \"${\n                    targetFn.originalName ?? targetFn.name\n                }\" composable, by using the makeDecoratable() function!`\n            );\n\n            return;\n        }\n\n        const decorators = Array.isArray(props.with) ? props.with : [props.with];\n        return composeComponent(targetFn.original, decorators as Enumerable<ComposeWith>, scope);\n    }, [props.with]);\n\n    return null;\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,iBAAA,GAAAF,OAAA;AASO,IAAMG,OAAO,GAAAC,OAAA,CAAAD,OAAA,GAAG,SAAVA,OAAOA,CAAIE,KAAmB,EAAK;EAC5C,IAAAC,eAAA,GAA6B,IAAAC,uBAAc,EAAC,CAAC;IAArCC,gBAAgB,GAAAF,eAAA,CAAhBE,gBAAgB;EACxB,IAAMC,KAAK,GAAG,IAAAC,qCAAmB,EAAC,CAAC;EAEnC,IAAMC,QAAQ,GAAIN,KAAK,CAACO,QAAQ,IAAIP,KAAK,CAACQ,SAAyB;EAEnE,IAAAC,gBAAS,EAAC,YAAM;IACZ,IAAI,OAAOH,QAAQ,CAACI,QAAQ,KAAK,WAAW,EAAE;MAC1CC,OAAO,CAACC,IAAI,kCAAAC,MAAA,CAEJP,QAAQ,CAACQ,YAAY,IAAIR,QAAQ,CAACS,IAAI,4DAE9C,CAAC;MAED;IACJ;IAEA,IAAMC,UAAU,GAAGC,KAAK,CAACC,OAAO,CAAClB,KAAK,CAACmB,IAAI,CAAC,GAAGnB,KAAK,CAACmB,IAAI,GAAG,CAACnB,KAAK,CAACmB,IAAI,CAAC;IACxE,OAAOhB,gBAAgB,CAACG,QAAQ,CAACI,QAAQ,EAAEM,UAAU,EAA6BZ,KAAK,CAAC;EAC5F,CAAC,EAAE,CAACJ,KAAK,CAACmB,IAAI,CAAC,CAAC;EAEhB,OAAO,IAAI;AACf,CAAC","ignoreList":[]}
+{"version":3,"names":["React","useEffect","useRef","useCompositionStore","useCompositionScope","Compose","props","store","scope","inherit","targetFn","function","component","console","warn","original","originalName","name","decorators","Array","isArray","with","currentScope","length","register","createElement","ComposeEffects","target","prevRef","prev","current","unregister"],"sources":["Compose.tsx"],"sourcesContent":["import React, { useEffect, useRef } from \"react\";\nimport type { DecoratableTypes } from \"./Context.js\";\nimport { useCompositionStore } from \"./Context.js\";\nimport { useCompositionScope } from \"~/CompositionScope.js\";\nimport type {\n    ComposeWith,\n    Decoratable,\n    Decorator,\n    GenericComponent,\n    GenericHook\n} from \"./types.js\";\n\nexport interface ComposeProps {\n    function?: DecoratableTypes;\n    component?: DecoratableTypes;\n    with: ComposeWith;\n}\n\nexport const Compose = (props: ComposeProps) => {\n    const store = useCompositionStore();\n    const { scope, inherit } = useCompositionScope();\n\n    const targetFn = (props.function ?? props.component) as Decoratable;\n\n    if (!targetFn) {\n        console.warn(\"You must provide a function or a component to compose with!\", props);\n        return null;\n    }\n\n    if (typeof targetFn.original === \"undefined\") {\n        console.warn(\n            `You must make your function \"${\n                targetFn.originalName ?? targetFn.name\n            }\" composable, by using the makeDecoratable() function!`\n        );\n        return null;\n    }\n\n    const decorators = (Array.isArray(props.with) ? props.with : [props.with]) as Decorator<\n        GenericComponent | GenericHook\n    >[];\n    const currentScope = scope[scope.length - 1] ?? \"*\";\n\n    // Register synchronously during render so decorators are available immediately.\n    // Pass silent=true to avoid notifying listeners mid-render (which would trigger\n    // setState in other components and cause React warnings).\n    store.register(targetFn.original, decorators, currentScope, inherit, true);\n\n    return (\n        <ComposeEffects\n            store={store}\n            target={targetFn.original}\n            decorators={decorators}\n            scope={currentScope}\n        />\n    );\n};\n\n/**\n * Separate component for the effect to avoid re-running the cleanup on every render.\n * This component handles cleanup on unmount and when props change.\n */\nfunction ComposeEffects({\n    store,\n    target,\n    decorators,\n    scope\n}: {\n    store: ReturnType<typeof useCompositionStore>;\n    target: any;\n    decorators: Decorator<GenericComponent | GenericHook>[];\n    scope: string;\n}) {\n    const prevRef = useRef<{\n        decorators: Decorator<GenericComponent | GenericHook>[];\n        scope: string;\n    } | null>(null);\n\n    useEffect(() => {\n        const prev = prevRef.current;\n\n        // On prop change: unregister old decorators.\n        if (prev && (prev.decorators !== decorators || prev.scope !== scope)) {\n            store.unregister(target, prev.decorators, prev.scope);\n            // Re-register new ones (they were already registered during render,\n            // but the idempotency check handles this).\n            store.register(target, decorators, scope);\n        }\n\n        prevRef.current = { decorators, scope };\n\n        // Cleanup on unmount.\n        return () => {\n            store.unregister(target, decorators, scope);\n        };\n    }, [store, target, decorators, scope]);\n\n    return null;\n}\n"],"mappings":"AAAA,OAAOA,KAAK,IAAIC,SAAS,EAAEC,MAAM,QAAQ,OAAO;AAEhD,SAASC,mBAAmB;AAC5B,SAASC,mBAAmB;AAe5B,OAAO,MAAMC,OAAO,GAAIC,KAAmB,IAAK;EAC5C,MAAMC,KAAK,GAAGJ,mBAAmB,CAAC,CAAC;EACnC,MAAM;IAAEK,KAAK;IAAEC;EAAQ,CAAC,GAAGL,mBAAmB,CAAC,CAAC;EAEhD,MAAMM,QAAQ,GAAIJ,KAAK,CAACK,QAAQ,IAAIL,KAAK,CAACM,SAAyB;EAEnE,IAAI,CAACF,QAAQ,EAAE;IACXG,OAAO,CAACC,IAAI,CAAC,6DAA6D,EAAER,KAAK,CAAC;IAClF,OAAO,IAAI;EACf;EAEA,IAAI,OAAOI,QAAQ,CAACK,QAAQ,KAAK,WAAW,EAAE;IAC1CF,OAAO,CAACC,IAAI,CACR,gCACIJ,QAAQ,CAACM,YAAY,IAAIN,QAAQ,CAACO,IAAI,wDAE9C,CAAC;IACD,OAAO,IAAI;EACf;EAEA,MAAMC,UAAU,GAAIC,KAAK,CAACC,OAAO,CAACd,KAAK,CAACe,IAAI,CAAC,GAAGf,KAAK,CAACe,IAAI,GAAG,CAACf,KAAK,CAACe,IAAI,CAErE;EACH,MAAMC,YAAY,GAAGd,KAAK,CAACA,KAAK,CAACe,MAAM,GAAG,CAAC,CAAC,IAAI,GAAG;;EAEnD;EACA;EACA;EACAhB,KAAK,CAACiB,QAAQ,CAACd,QAAQ,CAACK,QAAQ,EAAEG,UAAU,EAAEI,YAAY,EAAEb,OAAO,EAAE,IAAI,CAAC;EAE1E,oBACIT,KAAA,CAAAyB,aAAA,CAACC,cAAc;IACXnB,KAAK,EAAEA,KAAM;IACboB,MAAM,EAAEjB,QAAQ,CAACK,QAAS;IAC1BG,UAAU,EAAEA,UAAW;IACvBV,KAAK,EAAEc;EAAa,CACvB,CAAC;AAEV,CAAC;;AAED;AACA;AACA;AACA;AACA,SAASI,cAAcA,CAAC;EACpBnB,KAAK;EACLoB,MAAM;EACNT,UAAU;EACVV;AAMJ,CAAC,EAAE;EACC,MAAMoB,OAAO,GAAG1B,MAAM,CAGZ,IAAI,CAAC;EAEfD,SAAS,CAAC,MAAM;IACZ,MAAM4B,IAAI,GAAGD,OAAO,CAACE,OAAO;;IAE5B;IACA,IAAID,IAAI,KAAKA,IAAI,CAACX,UAAU,KAAKA,UAAU,IAAIW,IAAI,CAACrB,KAAK,KAAKA,KAAK,CAAC,EAAE;MAClED,KAAK,CAACwB,UAAU,CAACJ,MAAM,EAAEE,IAAI,CAACX,UAAU,EAAEW,IAAI,CAACrB,KAAK,CAAC;MACrD;MACA;MACAD,KAAK,CAACiB,QAAQ,CAACG,MAAM,EAAET,UAAU,EAAEV,KAAK,CAAC;IAC7C;IAEAoB,OAAO,CAACE,OAAO,GAAG;MAAEZ,UAAU;MAAEV;IAAM,CAAC;;IAEvC;IACA,OAAO,MAAM;MACTD,KAAK,CAACwB,UAAU,CAACJ,MAAM,EAAET,UAAU,EAAEV,KAAK,CAAC;IAC/C,CAAC;EACL,CAAC,EAAE,CAACD,KAAK,EAAEoB,MAAM,EAAET,UAAU,EAAEV,KAAK,CAAC,CAAC;EAEtC,OAAO,IAAI;AACf","ignoreList":[]}

package/CompositionScope.d.ts

@@ -1,11 +1,17 @@
 import React from "react";
 export interface CompositionScopeContext {
-    name: string;
+    inherit: boolean;
+    scope: string[];
 }
 interface CompositionScopeProps {
     name: string;
+    /**
+     * Use this prop on components that are used to register decorators.
+     * Components are inherited at the time of registration, and then cached.
+     */
+    inherit?: boolean;
     children: React.ReactNode;
 }
-export declare const CompositionScope: ({ name, children }: CompositionScopeProps) => React.JSX.Element;
-export declare function useCompositionScope(): string | undefined;
+export declare const CompositionScope: ({ name, inherit, children }: CompositionScopeProps) => React.JSX.Element;
+export declare function useCompositionScope(): CompositionScopeContext;
 export {};

package/CompositionScope.js

@@ -1,28 +1,27 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CompositionScope = void 0;
-exports.useCompositionScope = useCompositionScope;
-var _react = _interopRequireDefault(require("react"));
-var CompositionScopeContext = /*#__PURE__*/_react.default.createContext(undefined);
-var CompositionScope = exports.CompositionScope = function CompositionScope(_ref) {
-  var name = _ref.name,
-    children = _ref.children;
-  return /*#__PURE__*/_react.default.createElement(CompositionScopeContext.Provider, {
+import React from "react";
+const CompositionScopeContext = /*#__PURE__*/React.createContext(undefined);
+export const CompositionScope = ({
+  name,
+  inherit = false,
+  children
+}) => {
+  const parentScope = useCompositionScope();
+  return /*#__PURE__*/React.createElement(CompositionScopeContext.Provider, {
     value: {
-      name: name
+      scope: [...parentScope.scope, name],
+      inherit
     }
   }, children);
 };
-function useCompositionScope() {
-  var context = _react.default.useContext(CompositionScopeContext);
+export function useCompositionScope() {
+  const context = React.useContext(CompositionScopeContext);
   if (!context) {
-    return undefined;
+    return {
+      scope: [],
+      inherit: false
+    };
   }
-  return context.name;
+  return context;
 }
 
 //# sourceMappingURL=CompositionScope.js.map

package/CompositionScope.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","_interopRequireDefault","require","CompositionScopeContext","React","createContext","undefined","CompositionScope","exports","_ref","name","children","default","createElement","Provider","value","useCompositionScope","context","useContext"],"sources":["CompositionScope.tsx"],"sourcesContent":["import React from \"react\";\n\nexport interface CompositionScopeContext {\n    name: string;\n}\n\nconst CompositionScopeContext = React.createContext<CompositionScopeContext | undefined>(undefined);\n\ninterface CompositionScopeProps {\n    name: string;\n    children: React.ReactNode;\n}\n\nexport const CompositionScope = ({ name, children }: CompositionScopeProps) => {\n    return (\n        <CompositionScopeContext.Provider value={{ name }}>\n            {children}\n        </CompositionScopeContext.Provider>\n    );\n};\n\nexport function useCompositionScope() {\n    const context = React.useContext(CompositionScopeContext);\n    if (!context) {\n        return undefined;\n    }\n    return context.name;\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAMA,IAAMC,uBAAuB,gBAAGC,cAAK,CAACC,aAAa,CAAsCC,SAAS,CAAC;AAO5F,IAAMC,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG,SAAnBA,gBAAgBA,CAAAE,IAAA,EAAkD;EAAA,IAA5CC,IAAI,GAAAD,IAAA,CAAJC,IAAI;IAAEC,QAAQ,GAAAF,IAAA,CAARE,QAAQ;EAC7C,oBACIX,MAAA,CAAAY,OAAA,CAAAC,aAAA,CAACV,uBAAuB,CAACW,QAAQ;IAACC,KAAK,EAAE;MAAEL,IAAI,EAAJA;IAAK;EAAE,GAC7CC,QAC6B,CAAC;AAE3C,CAAC;AAEM,SAASK,mBAAmBA,CAAA,EAAG;EAClC,IAAMC,OAAO,GAAGb,cAAK,CAACc,UAAU,CAACf,uBAAuB,CAAC;EACzD,IAAI,CAACc,OAAO,EAAE;IACV,OAAOX,SAAS;EACpB;EACA,OAAOW,OAAO,CAACP,IAAI;AACvB","ignoreList":[]}
+{"version":3,"names":["React","CompositionScopeContext","createContext","undefined","CompositionScope","name","inherit","children","parentScope","useCompositionScope","createElement","Provider","value","scope","context","useContext"],"sources":["CompositionScope.tsx"],"sourcesContent":["import React from \"react\";\n\nexport interface CompositionScopeContext {\n    inherit: boolean;\n    scope: string[];\n}\n\nconst CompositionScopeContext = React.createContext<CompositionScopeContext | undefined>(undefined);\n\ninterface CompositionScopeProps {\n    name: string;\n    /**\n     * Use this prop on components that are used to register decorators.\n     * Components are inherited at the time of registration, and then cached.\n     */\n    inherit?: boolean;\n    children: React.ReactNode;\n}\n\nexport const CompositionScope = ({ name, inherit = false, children }: CompositionScopeProps) => {\n    const parentScope = useCompositionScope();\n\n    return (\n        <CompositionScopeContext.Provider value={{ scope: [...parentScope.scope, name], inherit }}>\n            {children}\n        </CompositionScopeContext.Provider>\n    );\n};\n\nexport function useCompositionScope() {\n    const context = React.useContext(CompositionScopeContext);\n\n    if (!context) {\n        return { scope: [], inherit: false };\n    }\n\n    return context;\n}\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AAOzB,MAAMC,uBAAuB,gBAAGD,KAAK,CAACE,aAAa,CAAsCC,SAAS,CAAC;AAYnG,OAAO,MAAMC,gBAAgB,GAAGA,CAAC;EAAEC,IAAI;EAAEC,OAAO,GAAG,KAAK;EAAEC;AAAgC,CAAC,KAAK;EAC5F,MAAMC,WAAW,GAAGC,mBAAmB,CAAC,CAAC;EAEzC,oBACIT,KAAA,CAAAU,aAAA,CAACT,uBAAuB,CAACU,QAAQ;IAACC,KAAK,EAAE;MAAEC,KAAK,EAAE,CAAC,GAAGL,WAAW,CAACK,KAAK,EAAER,IAAI,CAAC;MAAEC;IAAQ;EAAE,GACrFC,QAC6B,CAAC;AAE3C,CAAC;AAED,OAAO,SAASE,mBAAmBA,CAAA,EAAG;EAClC,MAAMK,OAAO,GAAGd,KAAK,CAACe,UAAU,CAACd,uBAAuB,CAAC;EAEzD,IAAI,CAACa,OAAO,EAAE;IACV,OAAO;MAAED,KAAK,EAAE,EAAE;MAAEP,OAAO,EAAE;IAAM,CAAC;EACxC;EAEA,OAAOQ,OAAO;AAClB","ignoreList":[]}

package/Context.d.ts

@@ -1,49 +1,35 @@
-import React, { ComponentType } from "react";
-import { ComposedFunction, ComposeWith, DecoratableComponent, DecoratableHook, Decorator, Enumerable, GenericComponent, GenericHook } from "./types";
+import type { ComponentType } from "react";
+import React from "react";
+import { CompositionStore } from "./domain/CompositionStore.js";
+import type { ComposeWith, Decoratable, DecoratableComponent, DecoratableHook, Decorator, Enumerable, GenericComponent, GenericHook } from "./types.js";
 export declare function compose<T>(...fns: Decorator<T>[]): (decoratee: T) => T;
-interface ComposedComponent {
-    /**
-     * Ready to use React component.
-     */
-    component: GenericHook | GenericComponent;
-    /**
-     * HOCs used to compose the original component.
-     */
-    hocs: Decorator<GenericComponent | GenericHook>[];
-    /**
-     * Component composition can be scoped.
-     */
-    scope?: string;
-}
 /**
  * @deprecated Use `Decorator` instead.
  */
 export interface HigherOrderComponent<TProps = any, TOutput = TProps> {
     (Component: GenericComponent<TProps>): GenericComponent<TOutput>;
 }
-declare type ComposedComponents = Map<ComponentType<unknown>, ComposedComponent>;
-declare type ComponentScopes = Map<string, ComposedComponents>;
-export declare type DecoratableTypes = DecoratableComponent | DecoratableHook;
-interface CompositionContextGetComponentCallable {
-    (component: ComponentType<unknown>, scope?: string): ComposedFunction | GenericComponent | undefined;
-}
-interface CompositionContext {
-    components: ComponentScopes;
-    getComponent: CompositionContextGetComponentCallable;
-    composeComponent(component: ComponentType<unknown>, hocs: Enumerable<ComposeWith>, scope?: string): void;
-}
-declare const CompositionContext: React.Context<CompositionContext | undefined>;
+export type DecoratableTypes = DecoratableComponent | DecoratableHook;
+export type DecoratorsTuple = [Decoratable, Decorator<any>[]];
+export type DecoratorsCollection = Array<DecoratorsTuple>;
 interface CompositionProviderProps {
+    decorators?: DecoratorsCollection;
     children: React.ReactNode;
 }
-export declare const CompositionProvider: ({ children }: CompositionProviderProps) => React.JSX.Element;
+export declare const CompositionProvider: ({ decorators, children }: CompositionProviderProps) => React.JSX.Element;
+export declare function useCompositionStore(): CompositionStore;
+export declare function useOptionalCompositionStore(): CompositionStore | undefined;
 export declare function useComponent<T>(baseFunction: T): T;
+interface CompositionContextValue {
+    composeComponent(component: ComponentType<unknown>, hocs: Enumerable<ComposeWith>, scope?: string, inherit?: boolean): () => void;
+    getComponent(component: ComponentType<unknown>, scope: string[]): GenericComponent | GenericHook | undefined;
+}
 /**
  * This hook will throw an error if composition context doesn't exist.
  */
-export declare function useComposition(): CompositionContext;
+export declare function useComposition(): CompositionContextValue;
 /**
  * This hook will not throw an error if composition context doesn't exist.
  */
-export declare function useOptionalComposition(): CompositionContext | undefined;
+export declare function useOptionalComposition(): CompositionContextValue | undefined;
 export {};

package/Context.js

@@ -1,27 +1,9 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CompositionProvider = void 0;
-exports.compose = compose;
-exports.useComponent = useComponent;
-exports.useComposition = useComposition;
-exports.useOptionalComposition = useOptionalComposition;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _react = _interopRequireWildcard(require("react"));
-var _CompositionScope = require("./CompositionScope");
-function compose() {
-  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
-    fns[_key] = arguments[_key];
-  }
-  return function (decoratee) {
-    return fns.reduceRight(function (decoratee, decorator) {
-      return decorator(decoratee);
-    }, decoratee);
+import React, { createContext, useContext, useRef, useSyncExternalStore } from "react";
+import { useCompositionScope } from "./CompositionScope.js";
+import { CompositionStore } from "./domain/CompositionStore.js";
+export function compose(...fns) {
+  return decoratee => {
+    return fns.reduceRight((decoratee, decorator) => decorator(decoratee), decoratee);
   };
 }
 
@@ -29,101 +11,81 @@ function compose() {
  * @deprecated Use `Decorator` instead.
  */
 
-var CompositionContext = /*#__PURE__*/(0, _react.createContext)(undefined);
-var CompositionProvider = exports.CompositionProvider = function CompositionProvider(_ref) {
-  var children = _ref.children;
-  var _useState = (0, _react.useState)(new Map()),
-    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
-    components = _useState2[0],
-    setComponents = _useState2[1];
-  var composeComponent = (0, _react.useCallback)(function (component, hocs) {
-    var scope = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "*";
-    setComponents(function (prevComponents) {
-      var components = new Map(prevComponents);
-      var scopeMap = components.get(scope) || new Map();
-      var recipe = scopeMap.get(component) || {
-        component: null,
-        hocs: []
-      };
-      var newHocs = [].concat((0, _toConsumableArray2.default)(recipe.hocs || []), (0, _toConsumableArray2.default)(hocs));
-      scopeMap.set(component, {
-        component: compose.apply(void 0, (0, _toConsumableArray2.default)((0, _toConsumableArray2.default)(newHocs).reverse()))(component),
-        hocs: newHocs
-      });
-      components.set(scope, scopeMap);
-      return components;
-    });
-
-    // Return a function that will remove the added HOCs.
-    return function () {
-      setComponents(function (prevComponents) {
-        var components = new Map(prevComponents);
-        var scopeMap = components.get(scope) || new Map();
-        var recipe = scopeMap.get(component) || {
-          component: null,
-          hocs: []
-        };
-        var newHOCs = (0, _toConsumableArray2.default)(recipe.hocs).filter(function (hoc) {
-          return !hocs.includes(hoc);
-        });
-        var NewComponent = compose.apply(void 0, (0, _toConsumableArray2.default)((0, _toConsumableArray2.default)(newHOCs).reverse()))(component);
-        scopeMap.set(component, {
-          component: NewComponent,
-          hocs: newHOCs
-        });
-        components.set(scope, scopeMap);
-        return components;
-      });
-    };
-  }, [setComponents]);
-  var getComponent = (0, _react.useCallback)(function (Component) {
-    var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "*";
-    var scopeMap = components.get(scope) || new Map();
-    var composedComponent = scopeMap.get(Component);
-    if (!composedComponent && scope !== "*") {
-      // Check if a default scope component exists
-      var defaultScopeMap = components.get("*") || new Map();
-      var defaultComponent = defaultScopeMap.get(Component);
-      return defaultComponent ? defaultComponent.component : undefined;
+const CompositionStoreContext = /*#__PURE__*/createContext(undefined);
+export const CompositionProvider = ({
+  decorators = [],
+  children
+}) => {
+  const storeRef = useRef(null);
+  if (storeRef.current === null) {
+    const store = new CompositionStore();
+    // Pre-register decorators from props.
+    for (const [decoratable, hocs] of decorators) {
+      store.register(decoratable.original, hocs);
     }
-    return composedComponent ? composedComponent.component : undefined;
-  }, [components]);
-  var context = (0, _react.useMemo)(function () {
-    return {
-      getComponent: getComponent,
-      composeComponent: composeComponent,
-      components: components
-    };
-  }, [components, composeComponent]);
-  return /*#__PURE__*/_react.default.createElement(CompositionContext.Provider, {
-    value: context
+    storeRef.current = store;
+  }
+  return /*#__PURE__*/React.createElement(CompositionStoreContext.Provider, {
+    value: storeRef.current
   }, children);
 };
-function useComponent(baseFunction) {
-  var context = useOptionalComposition();
-  var scope = (0, _CompositionScope.useCompositionScope)();
-  if (!context) {
+export function useCompositionStore() {
+  const store = useContext(CompositionStoreContext);
+  if (!store) {
+    throw new Error(`You're missing a <CompositionProvider> higher up in your component hierarchy!`);
+  }
+  return store;
+}
+export function useOptionalCompositionStore() {
+  return useContext(CompositionStoreContext);
+}
+export function useComponent(baseFunction) {
+  const store = useOptionalCompositionStore();
+  const scope = useCompositionScope();
+
+  // Subscribe to store changes so we re-render when compositions change.
+  useSyncExternalStore(store ? store.subscribe : noopSubscribe, store ? store.getSnapshot : noopGetSnapshot);
+  if (!store) {
     return baseFunction;
   }
-  return context.getComponent(baseFunction, scope) || baseFunction;
+  return store.getComponent(baseFunction, scope.scope) || baseFunction;
 }
+const noopSubscribe = () => () => {};
+const noopGetSnapshot = () => 0;
+
+// Legacy compatibility — kept for any external consumers.
 
 /**
  * This hook will throw an error if composition context doesn't exist.
  */
-function useComposition() {
-  var context = (0, _react.useContext)(CompositionContext);
-  if (!context) {
-    throw new Error("You're missing a <CompositionProvider> higher up in your component hierarchy!");
-  }
-  return context;
+export function useComposition() {
+  const store = useCompositionStore();
+  return {
+    composeComponent: (component, hocs, scope = "*", inherit = false) => {
+      return store.register(component, hocs, scope, inherit);
+    },
+    getComponent: (component, scope) => {
+      return store.getComponent(component, scope);
+    }
+  };
 }
 
 /**
  * This hook will not throw an error if composition context doesn't exist.
  */
-function useOptionalComposition() {
-  return (0, _react.useContext)(CompositionContext);
+export function useOptionalComposition() {
+  const store = useOptionalCompositionStore();
+  if (!store) {
+    return undefined;
+  }
+  return {
+    composeComponent: (component, hocs, scope = "*", inherit = false) => {
+      return store.register(component, hocs, scope, inherit);
+    },
+    getComponent: (component, scope) => {
+      return store.getComponent(component, scope);
+    }
+  };
 }
 
 //# sourceMappingURL=Context.js.map

package/Context.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","_interopRequireWildcard","require","_CompositionScope","compose","_len","arguments","length","fns","Array","_key","decoratee","reduceRight","decorator","CompositionContext","createContext","undefined","CompositionProvider","exports","_ref","children","_useState","useState","Map","_useState2","_slicedToArray2","default","components","setComponents","composeComponent","useCallback","component","hocs","scope","prevComponents","scopeMap","get","recipe","newHocs","concat","_toConsumableArray2","set","apply","reverse","newHOCs","filter","hoc","includes","NewComponent","getComponent","Component","composedComponent","defaultScopeMap","defaultComponent","context","useMemo","createElement","Provider","value","useComponent","baseFunction","useOptionalComposition","useCompositionScope","useComposition","useContext","Error"],"sources":["Context.tsx"],"sourcesContent":["import React, {\n    ComponentType,\n    createContext,\n    useCallback,\n    useContext,\n    useMemo,\n    useState\n} from \"react\";\nimport { useCompositionScope } from \"~/CompositionScope\";\nimport {\n    ComposedFunction,\n    ComposeWith,\n    DecoratableComponent,\n    DecoratableHook,\n    Decorator,\n    Enumerable,\n    GenericComponent,\n    GenericHook\n} from \"~/types\";\n\nexport function compose<T>(...fns: Decorator<T>[]) {\n    return (decoratee: T): T => {\n        return fns.reduceRight((decoratee, decorator) => decorator(decoratee), decoratee);\n    };\n}\n\ninterface ComposedComponent {\n    /**\n     * Ready to use React component.\n     */\n    component: GenericHook | GenericComponent;\n    /**\n     * HOCs used to compose the original component.\n     */\n    hocs: Decorator<GenericComponent | GenericHook>[];\n    /**\n     * Component composition can be scoped.\n     */\n    scope?: string;\n}\n\n/**\n * @deprecated Use `Decorator` instead.\n */\nexport interface HigherOrderComponent<TProps = any, TOutput = TProps> {\n    (Component: GenericComponent<TProps>): GenericComponent<TOutput>;\n}\n\ntype ComposedComponents = Map<ComponentType<unknown>, ComposedComponent>;\ntype ComponentScopes = Map<string, ComposedComponents>;\n\nexport type DecoratableTypes = DecoratableComponent | DecoratableHook;\n\ninterface CompositionContextGetComponentCallable {\n    (component: ComponentType<unknown>, scope?: string):\n        | ComposedFunction\n        | GenericComponent\n        | undefined;\n}\n\ninterface CompositionContext {\n    components: ComponentScopes;\n    getComponent: CompositionContextGetComponentCallable;\n    composeComponent(\n        component: ComponentType<unknown>,\n        hocs: Enumerable<ComposeWith>,\n        scope?: string\n    ): void;\n}\n\nconst CompositionContext = createContext<CompositionContext | undefined>(undefined);\n\ninterface CompositionProviderProps {\n    children: React.ReactNode;\n}\n\nexport const CompositionProvider = ({ children }: CompositionProviderProps) => {\n    const [components, setComponents] = useState<ComponentScopes>(new Map());\n\n    const composeComponent = useCallback(\n        (\n            component: GenericHook | GenericComponent,\n            hocs: HigherOrderComponent<any, any>[],\n            scope: string | undefined = \"*\"\n        ) => {\n            setComponents(prevComponents => {\n                const components = new Map(prevComponents);\n                const scopeMap: ComposedComponents = components.get(scope) || new Map();\n                const recipe = scopeMap.get(component) || { component: null, hocs: [] };\n\n                const newHocs = [...(recipe.hocs || []), ...hocs] as Decorator<\n                    GenericHook | GenericComponent\n                >[];\n\n                scopeMap.set(component, {\n                    component: compose(...[...newHocs].reverse())(component),\n                    hocs: newHocs\n                });\n\n                components.set(scope, scopeMap);\n                return components;\n            });\n\n            // Return a function that will remove the added HOCs.\n            return () => {\n                setComponents(prevComponents => {\n                    const components = new Map(prevComponents);\n                    const scopeMap: ComposedComponents = components.get(scope) || new Map();\n                    const recipe = scopeMap.get(component) || {\n                        component: null,\n                        hocs: []\n                    };\n\n                    const newHOCs = [...recipe.hocs].filter(hoc => !hocs.includes(hoc));\n                    const NewComponent = compose(...[...newHOCs].reverse())(component);\n\n                    scopeMap.set(component, {\n                        component: NewComponent,\n                        hocs: newHOCs\n                    });\n\n                    components.set(scope, scopeMap);\n                    return components;\n                });\n            };\n        },\n        [setComponents]\n    );\n\n    const getComponent = useCallback<CompositionContextGetComponentCallable>(\n        (Component, scope = \"*\") => {\n            const scopeMap: ComposedComponents = components.get(scope) || new Map();\n            const composedComponent = scopeMap.get(Component);\n            if (!composedComponent && scope !== \"*\") {\n                // Check if a default scope component exists\n                const defaultScopeMap: ComposedComponents = components.get(\"*\") || new Map();\n                const defaultComponent = defaultScopeMap.get(Component);\n                return defaultComponent ? defaultComponent.component : undefined;\n            }\n            return composedComponent ? composedComponent.component : undefined;\n        },\n        [components]\n    );\n\n    const context: CompositionContext = useMemo(\n        () => ({\n            getComponent,\n            composeComponent,\n            components\n        }),\n        [components, composeComponent]\n    );\n\n    return <CompositionContext.Provider value={context}>{children}</CompositionContext.Provider>;\n};\n\nexport function useComponent<T>(baseFunction: T) {\n    const context = useOptionalComposition();\n    const scope = useCompositionScope();\n\n    if (!context) {\n        return baseFunction;\n    }\n\n    return (context.getComponent(baseFunction as any, scope) || baseFunction) as T;\n}\n\n/**\n * This hook will throw an error if composition context doesn't exist.\n */\nexport function useComposition() {\n    const context = useContext(CompositionContext);\n    if (!context) {\n        throw new Error(\n            `You're missing a <CompositionProvider> higher up in your component hierarchy!`\n        );\n    }\n\n    return context;\n}\n\n/**\n * This hook will not throw an error if composition context doesn't exist.\n */\nexport function useOptionalComposition() {\n    return useContext(CompositionContext);\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["React","createContext","useContext","useRef","useSyncExternalStore","useCompositionScope","CompositionStore","compose","fns","decoratee","reduceRight","decorator","CompositionStoreContext","undefined","CompositionProvider","decorators","children","storeRef","current","store","decoratable","hocs","register","original","createElement","Provider","value","useCompositionStore","Error","useOptionalCompositionStore","useComponent","baseFunction","scope","subscribe","noopSubscribe","getSnapshot","noopGetSnapshot","getComponent","useComposition","composeComponent","component","inherit","useOptionalComposition"],"sources":["Context.tsx"],"sourcesContent":["import type { ComponentType } from \"react\";\nimport React, { createContext, useContext, useRef, useSyncExternalStore } from \"react\";\nimport { useCompositionScope } from \"~/CompositionScope.js\";\nimport { CompositionStore } from \"~/domain/CompositionStore.js\";\nimport type {\n    ComposeWith,\n    Decoratable,\n    DecoratableComponent,\n    DecoratableHook,\n    Decorator,\n    Enumerable,\n    GenericComponent,\n    GenericHook\n} from \"~/types.js\";\n\nexport function compose<T>(...fns: Decorator<T>[]) {\n    return (decoratee: T): T => {\n        return fns.reduceRight((decoratee, decorator) => decorator(decoratee), decoratee) as T;\n    };\n}\n\n/**\n * @deprecated Use `Decorator` instead.\n */\nexport interface HigherOrderComponent<TProps = any, TOutput = TProps> {\n    (Component: GenericComponent<TProps>): GenericComponent<TOutput>;\n}\n\nexport type DecoratableTypes = DecoratableComponent | DecoratableHook;\n\nconst CompositionStoreContext = createContext<CompositionStore | undefined>(undefined);\n\nexport type DecoratorsTuple = [Decoratable, Decorator<any>[]];\nexport type DecoratorsCollection = Array<DecoratorsTuple>;\n\ninterface CompositionProviderProps {\n    decorators?: DecoratorsCollection;\n    children: React.ReactNode;\n}\n\nexport const CompositionProvider = ({ decorators = [], children }: CompositionProviderProps) => {\n    const storeRef = useRef<CompositionStore | null>(null);\n    if (storeRef.current === null) {\n        const store = new CompositionStore();\n        // Pre-register decorators from props.\n        for (const [decoratable, hocs] of decorators) {\n            store.register(decoratable.original as ComponentType<unknown>, hocs);\n        }\n        storeRef.current = store;\n    }\n\n    return (\n        <CompositionStoreContext.Provider value={storeRef.current}>\n            {children}\n        </CompositionStoreContext.Provider>\n    );\n};\n\nexport function useCompositionStore(): CompositionStore {\n    const store = useContext(CompositionStoreContext);\n    if (!store) {\n        throw new Error(\n            `You're missing a <CompositionProvider> higher up in your component hierarchy!`\n        );\n    }\n    return store;\n}\n\nexport function useOptionalCompositionStore(): CompositionStore | undefined {\n    return useContext(CompositionStoreContext);\n}\n\nexport function useComponent<T>(baseFunction: T) {\n    const store = useOptionalCompositionStore();\n    const scope = useCompositionScope();\n\n    // Subscribe to store changes so we re-render when compositions change.\n    useSyncExternalStore(\n        store ? store.subscribe : noopSubscribe,\n        store ? store.getSnapshot : noopGetSnapshot\n    );\n\n    if (!store) {\n        return baseFunction;\n    }\n\n    return (store.getComponent(baseFunction as any, scope.scope) || baseFunction) as T;\n}\n\nconst noopSubscribe = () => () => {};\nconst noopGetSnapshot = () => 0;\n\n// Legacy compatibility — kept for any external consumers.\n\ninterface CompositionContextValue {\n    composeComponent(\n        component: ComponentType<unknown>,\n        hocs: Enumerable<ComposeWith>,\n        scope?: string,\n        inherit?: boolean\n    ): () => void;\n    getComponent(\n        component: ComponentType<unknown>,\n        scope: string[]\n    ): GenericComponent | GenericHook | undefined;\n}\n\n/**\n * This hook will throw an error if composition context doesn't exist.\n */\nexport function useComposition(): CompositionContextValue {\n    const store = useCompositionStore();\n\n    return {\n        composeComponent: (component, hocs, scope = \"*\", inherit = false) => {\n            return store.register(component, hocs as any[], scope, inherit);\n        },\n        getComponent: (component, scope) => {\n            return store.getComponent(component, scope);\n        }\n    };\n}\n\n/**\n * This hook will not throw an error if composition context doesn't exist.\n */\nexport function useOptionalComposition(): CompositionContextValue | undefined {\n    const store = useOptionalCompositionStore();\n    if (!store) {\n        return undefined;\n    }\n\n    return {\n        composeComponent: (component, hocs, scope = \"*\", inherit = false) => {\n            return store.register(component, hocs as any[], scope, inherit);\n        },\n        getComponent: (component, scope) => {\n            return store.getComponent(component, scope);\n        }\n    };\n}\n"],"mappings":"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","ignoreList":[]}

package/README.md

@@ -1,8 +1,11 @@
-# Validation
-[![](https://img.shields.io/npm/dw/@webiny/react-composition.svg)](https://www.npmjs.com/package/@webiny/react-composition) 
-[![](https://img.shields.io/npm/v/@webiny/react-composition.svg)](https://www.npmjs.com/package/@webiny/react-composition)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+# @webiny/react-composition
 
-A tiny composition framework for React components which makes it possible to compose components anywhere in your application. 
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
 
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/createDecorator.d.ts

@@ -1,18 +1,18 @@
 import React from "react";
-import { CanReturnNull, Decoratable, DecoratableComponent, DecoratableHook, Decorator } from "./types";
-declare type GetBaseFunction<T> = T extends DecoratableComponent<infer F> ? F : never;
+import type { CanReturnNullOrElement, Decoratable, DecoratableComponent, DecoratableHook, Decorator } from "./types.js";
+type GetBaseFunction<T> = T extends DecoratableComponent<infer F> ? F : never;
 /**
  * Creates a component which, when mounted, registers a Higher Order Component for the given base component.
  * This is particularly useful for decorating (wrapping) existing composable components.
  * For more information, visit https://www.webiny.com/docs/admin-area/basics/framework.
  */
-export declare function createComponentPlugin<T extends Decoratable>(Base: T, hoc: T extends DecoratableComponent ? Decorator<CanReturnNull<GetBaseFunction<T>>> : Decorator<GetBaseFunction<T>>): {
+export declare function createComponentPlugin<T extends Decoratable>(Base: T, hoc: T extends DecoratableComponent ? Decorator<CanReturnNullOrElement<GetBaseFunction<T>>> : Decorator<GetBaseFunction<T>>): {
     (): React.JSX.Element;
     displayName: string;
 };
-export declare type GetDecorateeParams<T> = T extends (params?: infer P1) => any ? P1 : T extends (params: infer P2) => any ? P2 : any;
-export declare type GetDecoratee<T> = T extends DecoratableHook<infer F> ? F : T extends DecoratableComponent<infer F> ? F : never;
-export declare function createDecorator<T extends Decoratable>(Base: T, hoc: T extends DecoratableComponent ? Decorator<CanReturnNull<GetBaseFunction<T>>> : Decorator<GetBaseFunction<T>>): {
+export type GetDecorateeParams<T> = T extends (params?: infer P1) => any ? P1 : T extends (params: infer P2) => any ? P2 : any;
+export type GetDecoratee<T> = T extends DecoratableHook<infer F> ? F : T extends DecoratableComponent<infer F> ? F : never;
+export declare function createDecorator<T extends Decoratable>(Base: T, hoc: T extends DecoratableComponent ? Decorator<CanReturnNullOrElement<GetBaseFunction<T>>> : Decorator<GetBaseFunction<T>>): {
     (): React.JSX.Element;
     displayName: string;
 };

package/createDecorator.js

@@ -1,35 +1,25 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createComponentPlugin = createComponentPlugin;
-exports.createDecorator = createDecorator;
-var _react = _interopRequireDefault(require("react"));
-var _Compose = require("./Compose");
+import React from "react";
+import { Compose } from "./Compose.js";
 /**
  * Creates a component which, when mounted, registers a Higher Order Component for the given base component.
  * This is particularly useful for decorating (wrapping) existing composable components.
  * For more information, visit https://www.webiny.com/docs/admin-area/basics/framework.
  */
-function createComponentPlugin(Base, hoc) {
+export function createComponentPlugin(Base, hoc) {
   return createDecorator(Base, hoc);
 }
 
 // Maybe there's a better way to mark params as non-existent, but for now I left it as `any`.
 // TODO: revisit this type; not sure if `?` can be handled in one clause
 
-var isDecoratableComponent = function isDecoratableComponent(decoratable) {
+const isDecoratableComponent = decoratable => {
   return "displayName" in decoratable;
 };
-function createDecorator(Base, hoc) {
-  var DecoratorPlugin = function DecoratorPlugin() {
-    return /*#__PURE__*/_react.default.createElement(_Compose.Compose, {
-      component: Base,
-      with: hoc
-    });
-  };
+export function createDecorator(Base, hoc) {
+  const DecoratorPlugin = () => /*#__PURE__*/React.createElement(Compose, {
+    component: Base,
+    with: hoc
+  });
   if (isDecoratableComponent(Base)) {
     DecoratorPlugin.displayName = Base.displayName;
   }