create-bluecopa-react-app 1.0.5 → 1.0.6

package/templates/latest/app/routes/home.tsx

@@ -0,0 +1,40 @@
+import { AppSidebar } from "~/components/app-sidebar"
+import { ChartAreaInteractive } from "~/components/chart-area-interactive"
+import { DataTable } from "~/components/data-table"
+import { SectionCards } from "~/components/section-cards"
+import { SiteHeader } from "~/components/site-header"
+import {
+  SidebarInset,
+  SidebarProvider,
+} from "~/components/ui/sidebar"
+
+import data from "~/dashboard/data.json"
+
+export default function Page() {
+  return (
+    <SidebarProvider
+      style={
+        {
+          "--sidebar-width": "calc(var(--spacing) * 72)",
+          "--header-height": "calc(var(--spacing) * 12)",
+        } as React.CSSProperties
+      }
+    >
+      <AppSidebar variant="inset" />
+      <SidebarInset>
+        <SiteHeader />
+        <div className="flex flex-1 flex-col">
+          <div className="@container/main flex flex-1 flex-col gap-2">
+            <div className="flex flex-col gap-4 py-4 md:gap-6 md:py-6">
+              <SectionCards />
+              <div className="px-4 lg:px-6">
+                <ChartAreaInteractive />
+              </div>
+              <DataTable data={data} />
+            </div>
+          </div>
+        </div>
+      </SidebarInset>
+    </SidebarProvider>
+  )
+}

package/templates/latest/app/routes.tsx

@@ -0,0 +1,15 @@
+import { Routes, Route, Navigate } from "react-router-dom";
+import { lazy } from "react";
+import "./app.css";
+
+const Home = lazy(() => import('~/routes/home'))
+
+
+export default function RouteConfig() {
+  return (
+    <Routes>
+      <Route path="/" element={<Home />} />
+      <Route path="*" element={<Navigate to="/" replace />} />
+    </Routes>
+  );
+}

package/templates/latest/{src → app}/single-spa.tsx

@@ -1,9 +1,9 @@
 import React from "react";
-import { createRoot, Root } from "react-dom/client";
+import { createRoot, type Root } from "react-dom/client";
 import singleSpaReact from "single-spa-react";
 import { MemoryRouter, BrowserRouter } from "react-router-dom";
-import App from "./App";
-import { AppProps } from "single-spa";
+import App from "./app";
+import type { AppProps } from "single-spa";
 
 // Single-spa lifecycle props interface
 interface LifecycleProps {

package/templates/latest/components.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "app/app.css",
+    "baseColor": "gray",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "~/components",
+    "utils": "~/lib/utils",
+    "ui": "~/components/ui",
+    "lib": "~/lib",
+    "hooks": "~/hooks"
+  },
+  "registries": {}
+}

package/templates/latest/dist/assets/__federation_expose_App-DRwKKpS2.js

@@ -0,0 +1,91 @@
+System.register(['./__federation_fn_import-CzfA7kmP.js', './client-DgSav55y.js'], (function (exports, module) {
+  'use strict';
+  var importShared, jsxRuntimeExports, clientExports, MemoryRouter, BrowserRouter, App;
+  return {
+    setters: [module => {
+      importShared = module.importShared;
+    }, module => {
+      jsxRuntimeExports = module.j;
+      clientExports = module.c;
+      MemoryRouter = module.M;
+      BrowserRouter = module.B;
+      App = module.A;
+    }],
+    execute: (async function () {
+
+      function e(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,o);}return n}function t(t){for(var n=1;n<arguments.length;n++){var r=null!=arguments[n]?arguments[n]:{};n%2?e(Object(r),true).forEach((function(e){o(t,e,r[e]);})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(r)):e(Object(r)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(r,e));}));}return t}function n(e){return (n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function o(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:true,configurable:true,writable:true}):e[t]=n,e}function r(e){return (r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function a(e,t){var n;if("function"!=typeof(n=t.domElement?function(){return t.domElement}:t.domElementGetter?t.domElementGetter:e.domElementGetter?e.domElementGetter:function(e){var t=e.appName||e.name;if(!t)throw Error("single-spa's dom-element-getter-helpers was not given an application name as a prop, so it can't make a unique dom element container for the react application");var n="single-spa-application:".concat(t);return function(){var e=document.getElementById(n);return e||((e=document.createElement("div")).id=n,document.body.appendChild(e)),e}}(t)))throw Error("single-spa's dom-element-getter-helpers was given an invalid domElementGetter for application or parcel '".concat(t.name,"'. Expected a function, received ").concat(r(n)));return function(){var e=n(t);if(!(e instanceof HTMLElement))throw Error("single-spa's dom-element-getter-helpers: domElementGetter returned an invalid dom element for application or parcel '".concat(t.name,"'. Expected HTMLElement, received ").concat(r(e)));return e}}var c=null;try{c=require("react").createContext();}catch(e){}var u={React:null,ReactDOM:null,ReactDOMClient:null,rootComponent:null,loadRootComponent:null,errorBoundary:null,errorBoundaryClass:null,domElementGetter:null,parcelCanUpdate:true,suppressComponentDidCatchWarning:false,domElements:{},renderResults:{},updateResolves:{},unmountResolves:{}};function i(e){if("object"!==n(e))throw new Error("single-spa-react requires a configuration object");var o,r=t(t({},u),e);if(!r.React)throw new Error("single-spa-react must be passed opts.React");if(!r.ReactDOM&&!r.ReactDOMClient)throw new Error("single-spa-react must be passed opts.ReactDOM or opts.ReactDOMClient");r.renderType||(null!==(o=r.ReactDOMClient)&&void 0!==o&&o.createRoot?r.renderType="createRoot":r.renderType="render");if(!r.rootComponent&&!r.loadRootComponent)throw new Error("single-spa-react must be passed opts.rootComponent or opts.loadRootComponent");if(r.errorBoundary&&"function"!=typeof r.errorBoundary)throw Error("The errorBoundary opt for single-spa-react must either be omitted or be a function that returns React elements");!c&&r.React.createContext&&(c=r.React.createContext()),r.SingleSpaRoot=function(e){function t(e){t.displayName="SingleSpaRoot(".concat(e.name,")");}return t.prototype=Object.create(e.React.Component.prototype),t.prototype.componentDidMount=function(){setTimeout(this.props.mountFinished);},t.prototype.componentWillUnmount=function(){setTimeout(this.props.unmountFinished);},t.prototype.render=function(){return setTimeout(this.props.updateFinished),this.props.children},t}(r);var a={bootstrap:s.bind(null,r),mount:p.bind(null,r),unmount:l.bind(null,r)};return r.parcelCanUpdate&&(a.update=m.bind(null,r)),a}function s(e,t){return e.rootComponent?Promise.resolve():e.loadRootComponent(t).then((function(t){e.rootComponent=t;}))}function p(e,t){return new Promise((function(n,o){e.suppressComponentDidCatchWarning||!function(e){if(!(e&&"string"==typeof e.version&&e.version.indexOf(".")>=0))return  false;var t=e.version.slice(0,e.version.indexOf("."));try{return Number(t)>=16}catch(e){return  false}}(e.React)||e.errorBoundary||e.errorBoundaryClass||(e.rootComponent.prototype?e.rootComponent.prototype.componentDidCatch||console.warn("single-spa-react: ".concat(t.name||t.appName||t.childAppName,"'s rootComponent should implement componentDidCatch to avoid accidentally unmounting the entire single-spa application.")):console.warn("single-spa-react: ".concat(t.name||t.appName||t.childAppName,"'s rootComponent does not implement an error boundary.  If using a functional component, consider providing an opts.errorBoundary to singleSpaReact(opts).")));var r=y(e,t,(function(){n(this);})),c=a(e,t)(),u=function(e){var t=e.reactDom,n=e.renderType,o=e.elementToRender,r=e.domElement,a=t[n];if("function"!=typeof a)throw new Error('renderType "'.concat(n,'" did not return a function.'));switch(n){case "createRoot":case "unstable_createRoot":case "createBlockingRoot":case "unstable_createBlockingRoot":var c=a(r);return c.render(o),c;case "hydrateRoot":return a(r,o);case "hydrate":default:return a(o,r),null}}({elementToRender:r,domElement:c,reactDom:d(e),renderType:f(e)});e.domElements[t.name]=c,e.renderResults[t.name]=u;}))}function l(e,t){return new Promise((function(n){e.unmountResolves[t.name]=n;var o=e.renderResults[t.name];o&&o.unmount?o.unmount():d(e).unmountComponentAtNode(e.domElements[t.name]),delete e.domElements[t.name],delete e.renderResults[t.name];}))}function m(e,t){return new Promise((function(n){e.updateResolves[t.name]||(e.updateResolves[t.name]=[]),e.updateResolves[t.name].push(n);var o=y(e,t,null),r=e.renderResults[t.name];if(r&&r.render)r.render(o);else {var c=a(e,t)();d(e).render(o,c);}}))}function d(e){return e.ReactDOMClient||e.ReactDOM}function f(e){return "function"==typeof e.renderType?e.renderType():e.renderType}function y(e,n,o){var r=e.React.createElement(e.rootComponent,n),a=c?e.React.createElement(c.Provider,{value:n},r):r;return (e.errorBoundary||n.errorBoundary||e.errorBoundaryClass||n.errorBoundaryClass)&&(e.errorBoundaryClass=e.errorBoundaryClass||n.errorBoundaryClass||function(e,t){function n(t){e.React.Component.apply(this,arguments),this.state={caughtError:null,caughtErrorInfo:null},n.displayName="SingleSpaReactErrorBoundary(".concat(t.name,")");}return n.prototype=Object.create(e.React.Component.prototype),n.prototype.render=function(){return this.state.caughtError?(e.errorBoundary||t.errorBoundary)(this.state.caughtError,this.state.caughtErrorInfo,this.props):this.props.children},n.prototype.componentDidCatch=function(e,t){this.setState({caughtError:e,caughtErrorInfo:t});},n}(e,n),a=e.React.createElement(e.errorBoundaryClass,n,a)),a=e.React.createElement(e.SingleSpaRoot,t(t({},n),{},{mountFinished:o,updateFinished:function(){e.updateResolves[n.name]&&(e.updateResolves[n.name].forEach((function(e){return e()})),delete e.updateResolves[n.name]);},unmountFinished:function(){e.unmountResolves[n.name]&&(e.unmountResolves[n.name](),delete e.unmountResolves[n.name]);}}),a)}
+
+      const React = await importShared('react');
+      let root = null;
+      const MicrofrontendRoot = ({ basename = "/", isMicroFrontend = false }) => {
+        const Router = isMicroFrontend ? MemoryRouter : BrowserRouter;
+        const routerProps = isMicroFrontend ? {} : { basename };
+        return /* @__PURE__ */ jsxRuntimeExports.jsx(Router, { ...routerProps, children: /* @__PURE__ */ jsxRuntimeExports.jsx(App, {}) });
+      };
+      const lifecycles = i({
+        React,
+        ReactDOMClient: { createRoot: clientExports.createRoot },
+        rootComponent: (props) => /* @__PURE__ */ jsxRuntimeExports.jsx(MicrofrontendRoot, { isMicroFrontend: true, basename: props.basename }),
+        errorBoundary: (err, info) => {
+          console.error("Microfrontend Single-spa Error:", err, info);
+          return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Something went wrong loading Microfrontend" });
+        },
+        renderType: "createRoot",
+        domElementGetter: () => {
+          const el = document.getElementById("single-spa-application:pnl-explorer");
+          if (!el)
+            throw new Error(
+              "Mount target #single-spa-application:pnl-explorer not found"
+            );
+          return el;
+        }
+      });
+      const { mount, unmount, bootstrap } = lifecycles; exports({ mount, unmount, bootstrap });
+      const manualMount = exports("manualMount", async (props) => {
+        if (!props.domElement) {
+          throw new Error("domElement is required for mounting the application");
+        }
+        try {
+          if (root) {
+            root.unmount();
+            root = null;
+          }
+          root = clientExports.createRoot(props.domElement);
+          root.render(
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              MicrofrontendRoot,
+              {
+                isMicroFrontend: true,
+                basename: props.basename || "/app/external/microfrontend"
+              }
+            )
+          );
+          console.log("Microfrontend mounted successfully");
+          return;
+        } catch (error) {
+          console.error("Failed to mount Microfrontend:", error);
+          throw error;
+        }
+      });
+      const manualUnmount = exports("manualUnmount", async () => {
+        try {
+          if (root) {
+            root.unmount();
+            root = null;
+          }
+          console.log("Microfrontend unmounted successfully");
+          return Promise.resolve();
+        } catch (error) {
+          console.error("Failed to unmount Microfrontend:", error);
+          return Promise.reject(error);
+        }
+      });
+      const singleSpa = exports("default", {
+        mount: manualMount,
+        unmount: manualUnmount,
+        bootstrap: () => Promise.resolve()
+      });
+
+    })
+  };
+}));

package/templates/latest/dist/assets/__federation_fn_import-CzfA7kmP.js

@@ -0,0 +1,438 @@
+System.register([], (function (exports, module) {
+  'use strict';
+  return {
+    execute: (function () {
+
+      exports({
+        importShared: importShared,
+        importSharedLocal: getSharedFromLocal,
+        importSharedRuntime: getSharedFromRuntime
+      });
+
+      const buildIdentifier = "[0-9A-Za-z-]+";
+      const build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
+      const numericIdentifier = "0|[1-9]\\d*";
+      const numericIdentifierLoose = "[0-9]+";
+      const nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+      const preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
+      const preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
+      const preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
+      const preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
+      const xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
+      const xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
+      const hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
+      const mainVersionLoose = `(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`;
+      const loosePlain = `[v=\\s]*${mainVersionLoose}${preReleaseLoose}?${build}?`;
+      const gtlt = "((?:<|>)?=?)";
+      const comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
+      const loneTilde = "(?:~>?)";
+      const tildeTrim = `(\\s*)${loneTilde}\\s+`;
+      const loneCaret = "(?:\\^)";
+      const caretTrim = `(\\s*)${loneCaret}\\s+`;
+      const star = "(<|>)?=?\\s*\\*";
+      const caret = `^${loneCaret}${xRangePlain}$`;
+      const mainVersion = `(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`;
+      const fullPlain = `v?${mainVersion}${preRelease}?${build}?`;
+      const tilde = `^${loneTilde}${xRangePlain}$`;
+      const xRange = `^${gtlt}\\s*${xRangePlain}$`;
+      const comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
+      const gte0 = "^\\s*>=\\s*0.0.0\\s*$";
+      function parseRegex(source) {
+        return new RegExp(source);
+      }
+      function isXVersion(version) {
+        return !version || version.toLowerCase() === "x" || version === "*";
+      }
+      function pipe(...fns) {
+        return (x) => {
+          return fns.reduce((v, f) => f(v), x);
+        };
+      }
+      function extractComparator(comparatorString) {
+        return comparatorString.match(parseRegex(comparator));
+      }
+      function combineVersion(major, minor, patch, preRelease2) {
+        const mainVersion2 = `${major}.${minor}.${patch}`;
+        if (preRelease2) {
+          return `${mainVersion2}-${preRelease2}`;
+        }
+        return mainVersion2;
+      }
+      function parseHyphen(range) {
+        return range.replace(
+          parseRegex(hyphenRange),
+          (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
+            if (isXVersion(fromMajor)) {
+              from = "";
+            } else if (isXVersion(fromMinor)) {
+              from = `>=${fromMajor}.0.0`;
+            } else if (isXVersion(fromPatch)) {
+              from = `>=${fromMajor}.${fromMinor}.0`;
+            } else {
+              from = `>=${from}`;
+            }
+            if (isXVersion(toMajor)) {
+              to = "";
+            } else if (isXVersion(toMinor)) {
+              to = `<${+toMajor + 1}.0.0-0`;
+            } else if (isXVersion(toPatch)) {
+              to = `<${toMajor}.${+toMinor + 1}.0-0`;
+            } else if (toPreRelease) {
+              to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
+            } else {
+              to = `<=${to}`;
+            }
+            return `${from} ${to}`.trim();
+          }
+        );
+      }
+      function parseComparatorTrim(range) {
+        return range.replace(parseRegex(comparatorTrim), "$1$2$3");
+      }
+      function parseTildeTrim(range) {
+        return range.replace(parseRegex(tildeTrim), "$1~");
+      }
+      function parseCaretTrim(range) {
+        return range.replace(parseRegex(caretTrim), "$1^");
+      }
+      function parseCarets(range) {
+        return range.trim().split(/\s+/).map((rangeVersion) => {
+          return rangeVersion.replace(
+            parseRegex(caret),
+            (_, major, minor, patch, preRelease2) => {
+              if (isXVersion(major)) {
+                return "";
+              } else if (isXVersion(minor)) {
+                return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+              } else if (isXVersion(patch)) {
+                if (major === "0") {
+                  return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+                } else {
+                  return `>=${major}.${minor}.0 <${+major + 1}.0.0-0`;
+                }
+              } else if (preRelease2) {
+                if (major === "0") {
+                  if (minor === "0") {
+                    return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${minor}.${+patch + 1}-0`;
+                  } else {
+                    return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
+                  }
+                } else {
+                  return `>=${major}.${minor}.${patch}-${preRelease2} <${+major + 1}.0.0-0`;
+                }
+              } else {
+                if (major === "0") {
+                  if (minor === "0") {
+                    return `>=${major}.${minor}.${patch} <${major}.${minor}.${+patch + 1}-0`;
+                  } else {
+                    return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+                  }
+                }
+                return `>=${major}.${minor}.${patch} <${+major + 1}.0.0-0`;
+              }
+            }
+          );
+        }).join(" ");
+      }
+      function parseTildes(range) {
+        return range.trim().split(/\s+/).map((rangeVersion) => {
+          return rangeVersion.replace(
+            parseRegex(tilde),
+            (_, major, minor, patch, preRelease2) => {
+              if (isXVersion(major)) {
+                return "";
+              } else if (isXVersion(minor)) {
+                return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+              } else if (isXVersion(patch)) {
+                return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+              } else if (preRelease2) {
+                return `>=${major}.${minor}.${patch}-${preRelease2} <${major}.${+minor + 1}.0-0`;
+              }
+              return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+            }
+          );
+        }).join(" ");
+      }
+      function parseXRanges(range) {
+        return range.split(/\s+/).map((rangeVersion) => {
+          return rangeVersion.trim().replace(
+            parseRegex(xRange),
+            (ret, gtlt2, major, minor, patch, preRelease2) => {
+              const isXMajor = isXVersion(major);
+              const isXMinor = isXMajor || isXVersion(minor);
+              const isXPatch = isXMinor || isXVersion(patch);
+              if (gtlt2 === "=" && isXPatch) {
+                gtlt2 = "";
+              }
+              preRelease2 = "";
+              if (isXMajor) {
+                if (gtlt2 === ">" || gtlt2 === "<") {
+                  return "<0.0.0-0";
+                } else {
+                  return "*";
+                }
+              } else if (gtlt2 && isXPatch) {
+                if (isXMinor) {
+                  minor = 0;
+                }
+                patch = 0;
+                if (gtlt2 === ">") {
+                  gtlt2 = ">=";
+                  if (isXMinor) {
+                    major = +major + 1;
+                    minor = 0;
+                    patch = 0;
+                  } else {
+                    minor = +minor + 1;
+                    patch = 0;
+                  }
+                } else if (gtlt2 === "<=") {
+                  gtlt2 = "<";
+                  if (isXMinor) {
+                    major = +major + 1;
+                  } else {
+                    minor = +minor + 1;
+                  }
+                }
+                if (gtlt2 === "<") {
+                  preRelease2 = "-0";
+                }
+                return `${gtlt2 + major}.${minor}.${patch}${preRelease2}`;
+              } else if (isXMinor) {
+                return `>=${major}.0.0${preRelease2} <${+major + 1}.0.0-0`;
+              } else if (isXPatch) {
+                return `>=${major}.${minor}.0${preRelease2} <${major}.${+minor + 1}.0-0`;
+              }
+              return ret;
+            }
+          );
+        }).join(" ");
+      }
+      function parseStar(range) {
+        return range.trim().replace(parseRegex(star), "");
+      }
+      function parseGTE0(comparatorString) {
+        return comparatorString.trim().replace(parseRegex(gte0), "");
+      }
+      function compareAtom(rangeAtom, versionAtom) {
+        rangeAtom = +rangeAtom || rangeAtom;
+        versionAtom = +versionAtom || versionAtom;
+        if (rangeAtom > versionAtom) {
+          return 1;
+        }
+        if (rangeAtom === versionAtom) {
+          return 0;
+        }
+        return -1;
+      }
+      function comparePreRelease(rangeAtom, versionAtom) {
+        const { preRelease: rangePreRelease } = rangeAtom;
+        const { preRelease: versionPreRelease } = versionAtom;
+        if (rangePreRelease === void 0 && !!versionPreRelease) {
+          return 1;
+        }
+        if (!!rangePreRelease && versionPreRelease === void 0) {
+          return -1;
+        }
+        if (rangePreRelease === void 0 && versionPreRelease === void 0) {
+          return 0;
+        }
+        for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
+          const rangeElement = rangePreRelease[i];
+          const versionElement = versionPreRelease[i];
+          if (rangeElement === versionElement) {
+            continue;
+          }
+          if (rangeElement === void 0 && versionElement === void 0) {
+            return 0;
+          }
+          if (!rangeElement) {
+            return 1;
+          }
+          if (!versionElement) {
+            return -1;
+          }
+          return compareAtom(rangeElement, versionElement);
+        }
+        return 0;
+      }
+      function compareVersion(rangeAtom, versionAtom) {
+        return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
+      }
+      function eq(rangeAtom, versionAtom) {
+        return rangeAtom.version === versionAtom.version;
+      }
+      function compare(rangeAtom, versionAtom) {
+        switch (rangeAtom.operator) {
+          case "":
+          case "=":
+            return eq(rangeAtom, versionAtom);
+          case ">":
+            return compareVersion(rangeAtom, versionAtom) < 0;
+          case ">=":
+            return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
+          case "<":
+            return compareVersion(rangeAtom, versionAtom) > 0;
+          case "<=":
+            return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
+          case void 0: {
+            return true;
+          }
+          default:
+            return false;
+        }
+      }
+      function parseComparatorString(range) {
+        return pipe(
+          parseCarets,
+          parseTildes,
+          parseXRanges,
+          parseStar
+        )(range);
+      }
+      function parseRange(range) {
+        return pipe(
+          parseHyphen,
+          parseComparatorTrim,
+          parseTildeTrim,
+          parseCaretTrim
+        )(range.trim()).split(/\s+/).join(" ");
+      }
+      function satisfy(version, range) {
+        if (!version) {
+          return false;
+        }
+        const parsedRange = parseRange(range);
+        const parsedComparator = parsedRange.split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ");
+        const comparators = parsedComparator.split(/\s+/).map((comparator2) => parseGTE0(comparator2));
+        const extractedVersion = extractComparator(version);
+        if (!extractedVersion) {
+          return false;
+        }
+        const [
+          ,
+          versionOperator,
+          ,
+          versionMajor,
+          versionMinor,
+          versionPatch,
+          versionPreRelease
+        ] = extractedVersion;
+        const versionAtom = {
+          version: combineVersion(
+            versionMajor,
+            versionMinor,
+            versionPatch,
+            versionPreRelease
+          ),
+          major: versionMajor,
+          minor: versionMinor,
+          patch: versionPatch,
+          preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split(".")
+        };
+        for (const comparator2 of comparators) {
+          const extractedComparator = extractComparator(comparator2);
+          if (!extractedComparator) {
+            return false;
+          }
+          const [
+            ,
+            rangeOperator,
+            ,
+            rangeMajor,
+            rangeMinor,
+            rangePatch,
+            rangePreRelease
+          ] = extractedComparator;
+          const rangeAtom = {
+            operator: rangeOperator,
+            version: combineVersion(
+              rangeMajor,
+              rangeMinor,
+              rangePatch,
+              rangePreRelease
+            ),
+            major: rangeMajor,
+            minor: rangeMinor,
+            patch: rangePatch,
+            preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split(".")
+          };
+          if (!compare(rangeAtom, versionAtom)) {
+            return false;
+          }
+        }
+        return true;
+      }
+
+      const currentImports = {};
+
+      // eslint-disable-next-line no-undef
+      const moduleMap = {'react':{get:()=>()=>__federation_import(new URL('__federation_shared_react-Bp6HVBS4.js', module.meta.url).href),import:true},'react-dom':{get:()=>()=>__federation_import(new URL('__federation_shared_react-dom-BCcRGiYp.js', module.meta.url).href),import:true}};
+      const moduleCache = Object.create(null);
+      async function importShared(name, shareScope = 'default') {
+        return moduleCache[name]
+          ? new Promise((r) => r(moduleCache[name]))
+          : (await getSharedFromRuntime(name, shareScope)) || getSharedFromLocal(name)
+      }
+      // eslint-disable-next-line
+      async function __federation_import(name) {
+        currentImports[name] ??= module.import(name);
+        return currentImports[name]
+      }
+      async function getSharedFromRuntime(name, shareScope) {
+        let module = null;
+        if (globalThis?.__federation_shared__?.[shareScope]?.[name]) {
+          const versionObj = globalThis.__federation_shared__[shareScope][name];
+          const requiredVersion = moduleMap[name]?.requiredVersion;
+          const hasRequiredVersion = !!requiredVersion;
+          if (hasRequiredVersion) {
+            const versionKey = Object.keys(versionObj).find((version) =>
+              satisfy(version, requiredVersion)
+            );
+            if (versionKey) {
+              const versionValue = versionObj[versionKey];
+              module = await (await versionValue.get())();
+            } else {
+              console.log(
+                `provider support ${name}(${versionKey}) is not satisfied requiredVersion(\${moduleMap[name].requiredVersion})`
+              );
+            }
+          } else {
+            const versionKey = Object.keys(versionObj)[0];
+            const versionValue = versionObj[versionKey];
+            module = await (await versionValue.get())();
+          }
+        }
+        if (module) {
+          return flattenModule(module, name)
+        }
+      }
+      async function getSharedFromLocal(name) {
+        if (moduleMap[name]?.import) {
+          let module = await (await moduleMap[name].get())();
+          return flattenModule(module, name)
+        } else {
+          console.error(
+            `consumer config import=false,so cant use callback shared module`
+          );
+        }
+      }
+      function flattenModule(module, name) {
+        // use a shared module which export default a function will getting error 'TypeError: xxx is not a function'
+        if (typeof module.default === 'function') {
+          Object.keys(module).forEach((key) => {
+            if (key !== 'default') {
+              module.default[key] = module[key];
+            }
+          });
+          moduleCache[name] = module.default;
+          return module.default
+        }
+        if (module.default) module = Object.assign({}, module.default, module);
+        moduleCache[name] = module;
+        return module
+      }
+
+    })
+  };
+}));

package/templates/latest/dist/assets/__federation_shared_react-Bp6HVBS4.js

@@ -0,0 +1,16 @@
+System.register(['./index-BzNimew1.js'], (function (exports, module) {
+	'use strict';
+	var requireReact, getDefaultExportFromCjs;
+	return {
+		setters: [module => {
+			requireReact = module.r;
+			getDefaultExportFromCjs = module.g;
+		}],
+		execute: (function () {
+
+			var reactExports = requireReact();
+			const index = exports("default", /*@__PURE__*/getDefaultExportFromCjs(reactExports));
+
+		})
+	};
+}));

package/templates/latest/dist/assets/__federation_shared_react-dom-BCcRGiYp.js

@@ -0,0 +1,17 @@
+System.register(['./index-BzNimew1.js', './index-DMFtQdNS.js'], (function (exports, module) {
+	'use strict';
+	var getDefaultExportFromCjs, requireReactDom;
+	return {
+		setters: [module => {
+			getDefaultExportFromCjs = module.g;
+		}, module => {
+			requireReactDom = module.r;
+		}],
+		execute: (function () {
+
+			var reactDomExports = requireReactDom();
+			const index = exports("default", /*@__PURE__*/getDefaultExportFromCjs(reactDomExports));
+
+		})
+	};
+}));