@fluentui-react-native/framework-base 0.2.0 → 0.3.0

package/lib-commonjs/component-patterns/render.types.d.ts

@@ -1,15 +1,19 @@
 import type React from 'react';
-import type ReactJSX from 'react/jsx-runtime';
+import type { FurnJSX } from '../jsx-namespace';
 /**
  * Base types for rendering components in a react application, extracted from react types
  */
-export type RenderResult = ReturnType<typeof ReactJSX.jsx>;
-export type RenderType = Parameters<typeof ReactJSX.jsx>[0] | string;
+export type RenderResult = FurnJSX.Element;
+export type RenderType = FurnJSX.ElementType;
 /**
  * The standard element type inputs for react and react-native. This might be View or Button, or it might be 'div' in web. Effectively
  * it is what react accepts for React.createElement
  */
 export type NativeReactType = RenderType;
+/**
+ * Get the props from a react component type
+ */
+export type PropsOf<TComponent> = TComponent extends React.JSXElementConstructor<infer P> ? P : never;
 /**
  * DIRECT RENDERING
  *
@@ -25,74 +29,96 @@ export type NativeReactType = RenderType;
 /**
  * type of the render function, not a FunctionComponent to help prevent hook usage
  */
-export type DirectComponentFunction<TProps> = (props: TProps) => RenderResult;
+export type FunctionComponentCore<TProps> = (props: TProps) => RenderResult;
+/**
+ * A function component that returns an element type. This allows for the empty call props usage for native
+ * components, as well as handles the returns of React components.
+ */
+export type FunctionComponent<TProps> = FunctionComponentCore<TProps> & {
+  displayName?: string;
+};
 /**
  * The full component definition that has the attached properties to allow the jsx handlers to render it directly.
  */
-export type DirectComponent<TProps> = DirectComponentFunction<TProps> & {
-    displayName?: string;
-    _callDirect?: boolean;
+export type DirectComponent<TProps> = FunctionComponentCore<TProps> & {
+  displayName?: string;
+  _callDirect?: boolean;
 };
+type LegacyComponentFunction<TProps> = (props: TProps, ...children: React.ReactNode[]) => RenderResult;
 /**
  * Legacy slot function type, this allows the rendering handlers to bypass the normal JSX rendering and call the function
  * directly. This expects the function to have children as the last argument of the call which isn't consistent with standard
  * react usage, where children are passed as a prop. If writing new components use the DirectComponent type instead.
  * @deprecated use DirectComponent instead
  */
-export type LegacyDirectComponent<TProps> = React.FunctionComponent<TProps> & {
-    _canCompose?: boolean;
+export type LegacyDirectComponent<TProps> = LegacyComponentFunction<TProps> & {
+  _canCompose?: boolean;
 };
 /**
- * Legacy type name used for consistency with old rendering patterns.
+ * Slot function type used in the composition framework. Slot functions return React elements (not arbitrary ReactNode values)
+ * since they always either call staged render functions or React.createElement.
  */
-export type SlotFn<TProps> = LegacyDirectComponent<TProps>;
+export type SlotFn<TProps> = {
+  (props: TProps, ...children: React.ReactNode[]): React.ReactElement | null;
+  _canCompose?: boolean;
+};
 /**
- * MULTI-STAGE RENDERING
+ * PHASED RENDERING (formerly called "staged" or "two-stage" rendering)
  *
- * The above direct rendering pattern is useful for simple components, but it does not allow for hooks or complex logic. The staged render pattern allows
- * for a component to be rendered in two stages, allowing for hooks to be used in the first stage and then the second stage to be a simple render function that can
+ * The above direct rendering pattern is useful for simple components, but it does not allow for hooks or complex logic. The phased render pattern allows
+ * for a component to be rendered in two phases, allowing for hooks to be used in the first phase and then the second phase to be a simple render function that can
  * be called directly.
  *
- * In code that respects the pattern the first stage will be called with props (though children will not be present) and will return a function that will be called
- * with additional props, this time with children present. This allows for the first stage to handle all the logic and hooks, while the second stage can be a simple render function
+ * In code that respects the pattern, the first phase will be called with props (though children will not be present) and will return a function that will be called
+ * with additional props, this time with children present. This allows for the first phase to handle all the logic and hooks, while the second phase can be a simple render function
  * that can leverage direct rendering if supported.
  *
- * The component itself will be a FunctionComponent, but it will have an attached property that is the staged render function. This allows the component to be used in two
+ * The component itself will be a FunctionComponent, but it will have an attached property that is the phased render function. This allows the component to be used in two
  * parts via the useSlot hook, or to be used directly in JSX/TSX as a normal component.
  */
 /**
- * This is an updated version of the staged render that handles children and types more consistently. Generally children
- * will be passed as part of the props for component rendering, it is inconsistent to have them as a variable argument.
+ * Phased render function signature. This is the recommended pattern for components that need hooks.
+ *
+ * Phase 1 receives props (without children) and can use hooks to compute derived state.
+ * Phase 2 returns a component that will be called with props including children.
  *
- * The `children` prop will be automatically inferred and typed correctly by the prop type. Hooks are still expected
+ * Children will be passed as part of the props for component rendering. The `children` prop will be
+ * automatically inferred and typed correctly by the prop type.
  */
-export type TwoStageRender<TProps> = (props: TProps) => React.ComponentType<React.PropsWithChildren<TProps>>;
+export type PhasedRender<TProps> = (props: TProps) => React.ComponentType<React.PropsWithChildren<TProps>>;
 /**
- * Component type for a component that can be rendered in two stages, with the attached render function.
+ * Component type for a component that can be rendered in two phases, with the attached phased render function.
+ * Use phasedComponent() to create these.
  */
-export type StagedComponent<TProps> = React.FunctionComponent<TProps> & {
-    _twoStageRender?: TwoStageRender<TProps>;
+export type PhasedComponent<TProps> = FunctionComponent<TProps> & {
+  _phasedRender?: PhasedRender<TProps>;
 };
 /**
- * The final rendering of the props in a staged render. This is the function component signature that matches that of
+ * The final rendering of the props in a phased render. This is the function component signature that matches that of
  * React.createElement, children (if present) will be part of the variable args at the end.
  */
-export type FinalRender<TProps> = (props: TProps, ...children: React.ReactNode[]) => JSX.Element | null;
+export type FinalRender<TProps> = (props: TProps, ...children: React.ReactNode[]) => FurnJSX.Element | null;
 /**
- * Signature for a staged render function.
- * @deprecated Use TwoStageRender instead
+ * Legacy staged render function signature.
+ * @deprecated Use PhasedRender instead. This older pattern splits children from props which is inconsistent with React conventions.
  */
 export type StagedRender<TProps> = (props: TProps, ...args: any[]) => FinalRender<TProps>;
 /**
- * Signature for a component that uses the staged render pattern.
- * @deprecated Use TwoStageRender instead
+ * Legacy component type that uses the staged render pattern.
+ * @deprecated Use PhasedComponent instead. Create with phasedComponent() rather than stagedComponent().
  */
-export type ComposableFunction<TProps> = React.FunctionComponent<TProps> & {
-    _staged?: StagedRender<TProps>;
+export type ComposableFunction<TProps> = FunctionComponent<TProps> & {
+  _staged?: StagedRender<TProps>;
 };
 /**
  * A type aggregating all the custom types that can be used in the render process.
  * @internal only used in this package, should not be exported
  */
-export type AnyCustomType<TProps> = React.FunctionComponent<TProps> | DirectComponent<TProps> | StagedComponent<TProps> | ComposableFunction<TProps> | LegacyDirectComponent<TProps>;
-//# sourceMappingURL=render.types.d.ts.map
+export type AnyCustomType<TProps> =
+  | React.FunctionComponent<TProps>
+  | DirectComponent<TProps>
+  | PhasedComponent<TProps>
+  | ComposableFunction<TProps>
+  | LegacyDirectComponent<TProps>;
+export {};
+//# sourceMappingURL=render.types.d.ts.map

package/lib-commonjs/component-patterns/render.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.types.d.ts","sourceRoot":"","sources":["../../src/component-patterns/render.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC3D,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC;AAEzC;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,MAAM,uBAAuB,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,uBAAuB,CAAC,MAAM,CAAC,GAAG;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,CAAC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG;IAC5E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,IAAI,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7G;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG;IACtE,eAAe,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;CAC1C,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;AAExG;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC;AAE1F;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAE9G;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAC5B,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAC/B,eAAe,CAAC,MAAM,CAAC,GACvB,eAAe,CAAC,MAAM,CAAC,GACvB,kBAAkB,CAAC,MAAM,CAAC,GAC1B,qBAAqB,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"render.types.d.ts","sourceRoot":"","sources":["../../src/component-patterns/render.types.ts"],"names":[],"mappings":"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"}

package/lib-commonjs/component-patterns/render.types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=render.types.js.map
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+//# sourceMappingURL=render.types.js.map

package/lib-commonjs/component-patterns/stagedComponent.d.ts

@@ -1,15 +1,10 @@
-import type { StagedComponent, TwoStageRender, StagedRender, ComposableFunction } from './render.types';
+import type { StagedRender, ComposableFunction } from './render.types';
 /**
  * Take a staged render function and make a real component out of it
  *
  * @param staged - staged render function to wrap into a staged component
  * @param memo - optional flag to enable wrapping the created component in a React.memo HOC
+ * @deprecated Use phasedComponent from phasedComponent.ts instead
  */
 export declare function stagedComponent<TProps>(staged: StagedRender<TProps>, memo?: boolean): ComposableFunction<TProps>;
-/**
- * Take a two stage render function and make a real component out of it, attaching the staged render function
- * so it can be split if used in that manner.
- * @param staged - two stage render function to wrap into a staged component
- */
-export declare function twoStageComponent<TProps>(staged: TwoStageRender<TProps>): StagedComponent<TProps>;
-//# sourceMappingURL=stagedComponent.d.ts.map
+//# sourceMappingURL=stagedComponent.d.ts.map

package/lib-commonjs/component-patterns/stagedComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stagedComponent.d.ts","sourceRoot":"","sources":["../../src/component-patterns/stagedComponent.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAMxG;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAQhH;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,CAUjG"}
+{"version":3,"file":"stagedComponent.d.ts","sourceRoot":"","sources":["../../src/component-patterns/stagedComponent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAMvE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAQhH"}

package/lib-commonjs/component-patterns/stagedComponent.js

@@ -1,44 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.twoStageComponent = exports.stagedComponent = void 0;
-const tslib_1 = require("tslib");
-/**
- * @jsxRuntime classic
- * @jsx withSlots
- */
-const React = tslib_1.__importStar(require("react"));
-const withSlots_1 = require("./withSlots");
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.stagedComponent = stagedComponent;
+const React = __importStar(require('react'));
 function asArray(val) {
-    return Array.isArray(val) ? val : [val];
+  return Array.isArray(val) ? val : [val];
 }
 /**
  * Take a staged render function and make a real component out of it
  *
  * @param staged - staged render function to wrap into a staged component
  * @param memo - optional flag to enable wrapping the created component in a React.memo HOC
+ * @deprecated Use phasedComponent from phasedComponent.ts instead
  */
 function stagedComponent(staged, memo) {
-    const component = (props) => {
-        const { children, ...rest } = props;
-        return staged(rest)({}, asArray(children));
-    };
-    const stagedComponent = memo ? React.memo(component) : component;
-    Object.assign(stagedComponent, { _staged: staged });
-    return stagedComponent;
-}
-exports.stagedComponent = stagedComponent;
-/**
- * Take a two stage render function and make a real component out of it, attaching the staged render function
- * so it can be split if used in that manner.
- * @param staged - two stage render function to wrap into a staged component
- */
-function twoStageComponent(staged) {
-    return Object.assign((props) => {
-        const { children, ...outerProps } = props;
-        const innerProps = { children };
-        const Inner = staged(outerProps);
-        return (0, withSlots_1.withSlots)(Inner, { ...innerProps });
-    }, { _twoStageRender: staged });
+  const component = (props) => {
+    const { children, ...rest } = props;
+    return staged(rest)({}, asArray(children));
+  };
+  const stagedComponent = memo ? React.memo(component) : component;
+  Object.assign(stagedComponent, { _staged: staged });
+  return stagedComponent;
 }
-exports.twoStageComponent = twoStageComponent;
-//# sourceMappingURL=stagedComponent.js.map
+//# sourceMappingURL=stagedComponent.js.map

package/lib-commonjs/component-patterns/stagedComponent.js.map

@@ -1 +1 @@
-{"version":3,"file":"stagedComponent.js","sourceRoot":"","sources":["../../src/component-patterns/stagedComponent.tsx"],"names":[],"mappings":";;;;AAAA;;;GAGG;AACH,qDAA+B;AAC/B,2CAAwC;AAIxC,SAAS,OAAO,CAAI,GAAY;IAC9B,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,SAAgB,eAAe,CAAS,MAA4B,EAAE,IAAc;IAClF,MAAM,SAAS,GAAG,CAAC,KAAsC,EAAE,EAAE;QAC3D,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;QACpC,OAAO,MAAM,CAAC,IAAc,CAAC,CAAC,EAAqC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1F,CAAC,CAAC;IACF,MAAM,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,OAAO,eAA6C,CAAC;AACvD,CAAC;AARD,0CAQC;AAED;;;;GAIG;AACH,SAAgB,iBAAiB,CAAS,MAA8B;IACtE,OAAO,MAAM,CAAC,MAAM,CAClB,CAAC,KAAsC,EAAE,EAAE;QACzC,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,GAAG,KAAK,CAAC;QAC1C,MAAM,UAAU,GAAG,EAAE,QAAQ,EAAqC,CAAC;QACnE,MAAM,KAAK,GAAG,MAAM,CAAC,UAAoB,CAAC,CAAC;QAC3C,OAAO,2BAAC,KAAK,OAAK,UAAU,GAAI,CAAC;IACnC,CAAC,EACD,EAAE,eAAe,EAAE,MAAM,EAAE,CAC5B,CAAC;AACJ,CAAC;AAVD,8CAUC"}
+{"version":3,"file":"stagedComponent.js","sourceRoot":"","sources":["../../src/component-patterns/stagedComponent.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAY,KAAK,kCAAc;AAI/B,SAAS,OAAO,CAAI,GAAY,EAAO;IACrC,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAAA,CACzC;AAED;;;;;;GAMG;AACH,yBAAwC,MAA4B,EAAE,IAAc,EAA8B;IAChH,MAAM,SAAS,GAAG,CAAC,KAAsC,EAAE,EAAE,CAAC;QAC5D,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;QACpC,OAAO,MAAM,CAAC,IAAc,CAAC,CAAC,EAAqC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAAA,CACzF,CAAC;IACF,MAAM,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,OAAO,eAA6C,CAAC;AAAA,CACtD"}

package/lib-commonjs/component-patterns/withSlots.d.ts

@@ -11,5 +11,9 @@ import type React from 'react';
  *
  * See React.createElement
  */
-export declare function withSlots(reactType: Parameters<typeof React.createElement>[0], props?: unknown, ...children: React.ReactNode[]): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-//# sourceMappingURL=withSlots.d.ts.map
+export declare function withSlots(
+  reactType: Parameters<typeof React.createElement>[0],
+  props?: unknown,
+  ...children: React.ReactNode[]
+): import('..').FurnJSX.Element;
+//# sourceMappingURL=withSlots.d.ts.map

package/lib-commonjs/component-patterns/withSlots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withSlots.d.ts","sourceRoot":"","sources":["../../src/component-patterns/withSlots.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;;;;;;;;;;GAWG;AAGH,wBAAgB,SAAS,CAAC,SAAS,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE,KAAK,CAAC,SAAS,EAAE,sEAG9H"}
+{"version":3,"file":"withSlots.d.ts","sourceRoot":"","sources":["../../src/component-patterns/withSlots.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;;;;;;;;;;GAWG;AAGH,wBAAgB,SAAS,CAAC,SAAS,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE,KAAK,CAAC,SAAS,EAAE,gCAG9H"}

package/lib-commonjs/component-patterns/withSlots.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withSlots = void 0;
-const render_1 = require("./render");
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.withSlots = withSlots;
+const render_1 = require('./render');
 /**
  * This function is required for any module that uses slots.
  *
@@ -16,8 +16,7 @@ const render_1 = require("./render");
  */
 // Can't use typeof on React.createElement since it's overloaded. Approximate createElement's signature for now and widen as needed.
 function withSlots(reactType, props, ...children) {
-    // if it is a non-string type with _canCompose set just call the function directly, otherwise call createElement as normal
-    return (0, render_1.renderForClassicRuntime)(reactType, props, ...children);
+  // if it is a non-string type with _canCompose set just call the function directly, otherwise call createElement as normal
+  return (0, render_1.renderForClassicRuntime)(reactType, props, ...children);
 }
-exports.withSlots = withSlots;
-//# sourceMappingURL=withSlots.js.map
+//# sourceMappingURL=withSlots.js.map

package/lib-commonjs/component-patterns/withSlots.js.map

@@ -1 +1 @@
-{"version":3,"file":"withSlots.js","sourceRoot":"","sources":["../../src/component-patterns/withSlots.tsx"],"names":[],"mappings":";;;AACA,qCAAmD;AAEnD;;;;;;;;;;;GAWG;AAEH,oIAAoI;AACpI,SAAgB,SAAS,CAAC,SAAoD,EAAE,KAAe,EAAE,GAAG,QAA2B;IAC7H,0HAA0H;IAC1H,OAAO,IAAA,gCAAuB,EAAC,SAAS,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,CAAC;AAChE,CAAC;AAHD,8BAGC"}
+{"version":3,"file":"withSlots.js","sourceRoot":"","sources":["../../src/component-patterns/withSlots.tsx"],"names":[],"mappings":";;;AACA,qCAAmD;AAEnD;;;;;;;;;;;GAWG;AAEH,oIAAoI;AACpI,mBAA0B,SAAoD,EAAE,KAAe,EAAE,GAAG,QAA2B,EAAE;IAC/H,0HAA0H;IAC1H,OAAO,IAAA,gCAAuB,EAAC,SAAS,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,CAAC;AAAA,CAC/D"}

package/lib-commonjs/immutable-merge/Merge.d.ts

@@ -41,7 +41,7 @@ export type ExpandedTypeof = TypeofResult | 'array' | 'null';
  * - [key: string]: matches anything by name
  */
 export interface MergeOptions {
-    [objectTypeOrKeyName: string]: RecursionOption | RecursionHandler | MergeOptions;
+  [objectTypeOrKeyName: string]: RecursionOption | RecursionHandler | MergeOptions;
 }
 /**
  * Filter a set of unknown values to only include those that extend ObjectBase
@@ -62,7 +62,10 @@ export declare function immutableMerge<T extends ObjectBase>(...objs: (T | undef
  * @param options - configuration options for the merge, this dictates what keys will be handled in what way
  * @param objs - set of objects to merge together
  */
-export declare function immutableMergeCore<T extends ObjectBase>(options: RecursionOption | MergeOptions, ...objs: (T | undefined)[]): T | undefined;
+export declare function immutableMergeCore<T extends ObjectBase>(
+  options: RecursionOption | MergeOptions,
+  ...objs: (T | undefined)[]
+): T | undefined;
 /**
  * Process one or more immutable objects ensuring that handlers are called on every entry that applies.  If a single object
  * is passed in and no changes are made, that object will be returned.  If updates happen from the handlers it will return the
@@ -75,4 +78,4 @@ export declare function immutableMergeCore<T extends ObjectBase>(options: Recurs
  * @param objs - one or more objects to process.  If multiple objects are passed they will be merged
  */
 export declare function processImmutable<T extends ObjectBase>(options: MergeOptions, ...objs: (T | undefined)[]): T | undefined;
-//# sourceMappingURL=Merge.d.ts.map
+//# sourceMappingURL=Merge.d.ts.map