@hanzogui/create-context 2.0.0-rc.41-hanzoai.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/dist/cjs/create-context.cjs

@@ -0,0 +1,142 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var create_context_exports = {};
+__export(create_context_exports, {
+  createContext: () => createContext,
+  createContextScope: () => createContextScope
+});
+module.exports = __toCommonJS(create_context_exports);
+var React = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function createContext(rootComponentName, defaultContext) {
+  const Context = React.createContext(defaultContext);
+  function Provider(props) {
+    const {
+      children,
+      ...context
+    } = props;
+    const value = React.useMemo(() => context, Object.values(context));
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Context.Provider, {
+      value,
+      children
+    });
+  }
+  function useContext(consumerName) {
+    const context = React.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  return [Provider, useContext];
+}
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    const BaseContext = React.createContext(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      const {
+        scope,
+        children,
+        ...context
+      } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = React.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Context.Provider, {
+        value,
+        children
+      });
+    }
+    function useContext(consumerName, scope, options) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      const missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options?.fallback) {
+        if (options?.warn !== false) {
+          console.warn(missingContextMessage);
+        }
+        return options.fallback;
+      }
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map(defaultContext => {
+      return React.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(() => ({
+        [`__scope${scopeName}`]: {
+          ...scope,
+          [scopeName]: contexts
+        }
+      }), [scope, contexts]);
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext2, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = () => {
+    const scopeHooks = scopes.map(createScope2 => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, {
+        useScope,
+        scopeName
+      }) => {
+        const scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(() => ({
+        [`__scope${baseScope.scopeName}`]: nextScopes
+      }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}

package/dist/cjs/create-context.native.js

@@ -0,0 +1,162 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var create_context_exports = {};
+__export(create_context_exports, {
+  createContext: () => createContext,
+  createContextScope: () => createContextScope
+});
+module.exports = __toCommonJS(create_context_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var React = __toESM(require("react"), 1);
+function createContext(rootComponentName, defaultContext) {
+  var Context = /* @__PURE__ */React.createContext(defaultContext);
+  function Provider(props) {
+    var {
+      children,
+      ...context
+    } = props;
+    var value = React.useMemo(function () {
+      return context;
+    }, Object.values(context));
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Context.Provider, {
+      value,
+      children
+    });
+  }
+  function useContext(consumerName) {
+    var context = React.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  return [Provider, useContext];
+}
+function createContextScope(scopeName) {
+  var createContextScopeDeps = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    var BaseContext = /* @__PURE__ */React.createContext(defaultContext);
+    var index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      var _scope_scopeName;
+      var {
+        scope,
+        children,
+        ...context
+      } = props;
+      var Context = (scope === null || scope === void 0 ? void 0 : (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext;
+      var value = React.useMemo(function () {
+        return context;
+      }, Object.values(context));
+      return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Context.Provider, {
+        value,
+        children
+      });
+    }
+    function useContext(consumerName, scope, options) {
+      var _scope_scopeName;
+      var Context = (scope === null || scope === void 0 ? void 0 : (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext;
+      var context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      var missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options === null || options === void 0 ? void 0 : options.fallback) {
+        if ((options === null || options === void 0 ? void 0 : options.warn) !== false) {
+          console.warn(missingContextMessage);
+        }
+        return options.fallback;
+      }
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  var createScope = function () {
+    var scopeContexts = defaultContexts.map(function (defaultContext) {
+      return /* @__PURE__ */React.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      var contexts = (scope === null || scope === void 0 ? void 0 : scope[scopeName]) || scopeContexts;
+      return React.useMemo(function () {
+        return {
+          [`__scope${scopeName}`]: {
+            ...scope,
+            [scopeName]: contexts
+          }
+        };
+      }, [scope, contexts]);
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext2, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes() {
+  for (var _len = arguments.length, scopes = new Array(_len), _key = 0; _key < _len; _key++) {
+    scopes[_key] = arguments[_key];
+  }
+  var baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  var createScope = function () {
+    var scopeHooks = scopes.map(function (createScope2) {
+      return {
+        useScope: createScope2(),
+        scopeName: createScope2.scopeName
+      };
+    });
+    return function useComposedScopes(overrideScopes) {
+      var nextScopes = scopeHooks.reduce(function (nextScopes2, param) {
+        var {
+          useScope,
+          scopeName
+        } = param;
+        var scopeProps = useScope(overrideScopes);
+        var currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(function () {
+        return {
+          [`__scope${baseScope.scopeName}`]: nextScopes
+        };
+      }, [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+//# sourceMappingURL=create-context.native.js.map

package/dist/cjs/create-context.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","create_context_exports","__export","createContext","createContextScope","module","exports","import_jsx_runtime","require","React","__toESM","rootComponentName","defaultContext","Context","Provider","props","children","context","useMemo","Object","values","jsx","useContext","consumerName","Error","scopeName","createContextScopeDeps","arguments","length","defaultContexts","createContext2","BaseContext","index","_scope_scopeName","scope","options","missingContextMessage","fallback","warn","console","createScope","scopeContexts","map","useScope","contexts"],"sources":["../../src/create-context.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/index.cjs

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./create-context.cjs"), module.exports);

package/dist/cjs/index.native.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./create-context.native.js"), module.exports);
+//# sourceMappingURL=index.native.js.map

package/dist/cjs/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","module","exports"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAP,YAAc,CAAAK,aAAA","ignoreList":[]}

package/dist/esm/create-context.mjs

@@ -0,0 +1,105 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+function createContext(rootComponentName, defaultContext) {
+  const Context = React.createContext(defaultContext);
+  function Provider(props) {
+    const {
+      children,
+      ...context
+    } = props;
+    const value = React.useMemo(() => context, Object.values(context));
+    return /* @__PURE__ */jsx(Context.Provider, {
+      value,
+      children
+    });
+  }
+  function useContext(consumerName) {
+    const context = React.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  return [Provider, useContext];
+}
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    const BaseContext = React.createContext(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      const {
+        scope,
+        children,
+        ...context
+      } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = React.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */jsx(Context.Provider, {
+        value,
+        children
+      });
+    }
+    function useContext(consumerName, scope, options) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      const missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options?.fallback) {
+        if (options?.warn !== false) {
+          console.warn(missingContextMessage);
+        }
+        return options.fallback;
+      }
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map(defaultContext => {
+      return React.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(() => ({
+        [`__scope${scopeName}`]: {
+          ...scope,
+          [scopeName]: contexts
+        }
+      }), [scope, contexts]);
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext2, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = () => {
+    const scopeHooks = scopes.map(createScope2 => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, {
+        useScope,
+        scopeName
+      }) => {
+        const scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(() => ({
+        [`__scope${baseScope.scopeName}`]: nextScopes
+      }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+export { createContext, createContextScope };
+//# sourceMappingURL=create-context.mjs.map

package/dist/esm/create-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","jsx","createContext","rootComponentName","defaultContext","Context","Provider","props","children","context","value","useMemo","Object","values","useContext","consumerName","Error","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createContext2","BaseContext","index","length","scope","options","missingContextMessage","fallback","warn","console","createScope","scopeContexts","map","useScope","contexts","composeContextScopes","scopes","baseScope","scopeHooks","createScope2","useComposedScopes","overrideScopes","nextScopes","reduce","nextScopes2","scopeProps","currentScope"],"sources":["../../src/create-context.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/create-context.native.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+function createContext(rootComponentName, defaultContext) {
+  var Context = /* @__PURE__ */React.createContext(defaultContext);
+  function Provider(props) {
+    var {
+      children,
+      ...context
+    } = props;
+    var value = React.useMemo(function () {
+      return context;
+    }, Object.values(context));
+    return /* @__PURE__ */_jsx(Context.Provider, {
+      value,
+      children
+    });
+  }
+  function useContext(consumerName) {
+    var context = React.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  return [Provider, useContext];
+}
+function createContextScope(scopeName) {
+  var createContextScopeDeps = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  var defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    var BaseContext = /* @__PURE__ */React.createContext(defaultContext);
+    var index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      var _scope_scopeName;
+      var {
+        scope,
+        children,
+        ...context
+      } = props;
+      var Context = (scope === null || scope === void 0 ? void 0 : (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext;
+      var value = React.useMemo(function () {
+        return context;
+      }, Object.values(context));
+      return /* @__PURE__ */_jsx(Context.Provider, {
+        value,
+        children
+      });
+    }
+    function useContext(consumerName, scope, options) {
+      var _scope_scopeName;
+      var Context = (scope === null || scope === void 0 ? void 0 : (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext;
+      var context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      var missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options === null || options === void 0 ? void 0 : options.fallback) {
+        if ((options === null || options === void 0 ? void 0 : options.warn) !== false) {
+          console.warn(missingContextMessage);
+        }
+        return options.fallback;
+      }
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  var createScope = function () {
+    var scopeContexts = defaultContexts.map(function (defaultContext) {
+      return /* @__PURE__ */React.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      var contexts = (scope === null || scope === void 0 ? void 0 : scope[scopeName]) || scopeContexts;
+      return React.useMemo(function () {
+        return {
+          [`__scope${scopeName}`]: {
+            ...scope,
+            [scopeName]: contexts
+          }
+        };
+      }, [scope, contexts]);
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext2, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes() {
+  for (var _len = arguments.length, scopes = new Array(_len), _key = 0; _key < _len; _key++) {
+    scopes[_key] = arguments[_key];
+  }
+  var baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  var createScope = function () {
+    var scopeHooks = scopes.map(function (createScope2) {
+      return {
+        useScope: createScope2(),
+        scopeName: createScope2.scopeName
+      };
+    });
+    return function useComposedScopes(overrideScopes) {
+      var nextScopes = scopeHooks.reduce(function (nextScopes2, param) {
+        var {
+          useScope,
+          scopeName
+        } = param;
+        var scopeProps = useScope(overrideScopes);
+        var currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(function () {
+        return {
+          [`__scope${baseScope.scopeName}`]: nextScopes
+        };
+      }, [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+export { createContext, createContextScope };
+//# sourceMappingURL=create-context.native.js.map

package/dist/esm/create-context.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsx","_jsx","React","createContext","rootComponentName","defaultContext","Context","Provider","props","children","context","value","useMemo","Object","values","useContext","consumerName","Error","createContextScope","scopeName","createContextScopeDeps","arguments","length","defaultContexts","createContext2","BaseContext","index","_scope_scopeName","scope","options","missingContextMessage","fallback","warn","console","createScope","scopeContexts","map","useScope","contexts"],"sources":["../../src/create-context.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from "./create-context.mjs";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/esm/index.mjs

@@ -0,0 +1,2 @@
+export * from "./create-context.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/esm/index.native.js

@@ -0,0 +1,2 @@
+export * from "./create-context.native.js";
+//# sourceMappingURL=index.native.js.map

package/dist/esm/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc","ignoreList":[]}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@hanzogui/create-context",
+  "version": "2.0.0-rc.41-hanzoai.5",
+  "gitHead": "a49cc7ea6b93ba384e77a4880ae48ac4a5635c14",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/cjs",
+  "module": "dist/esm",
+  "types": "./types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts",
+      "react-native": "./dist/esm/index.native.js",
+      "browser": "./dist/esm/index.mjs",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "hanzogui-build",
+    "watch": "hanzogui-build --watch",
+    "clean": "hanzogui-build clean",
+    "clean:build": "hanzogui-build clean:build"
+  },
+  "devDependencies": {
+    "@hanzogui/build": "2.0.0-rc.41-hanzoai.5",
+    "react": ">=19"
+  },
+  "peerDependencies": {
+    "react": ">=19"
+  }
+}

package/src/create-context.tsx

@@ -0,0 +1,192 @@
+// from radix
+// https://github.com/radix-ui/primitives/blob/main/packages/react/context/src/createContext.tsx
+
+import * as React from 'react'
+
+export type ScopedProps<P, K extends string> = P & { [Key in `__scope${K}`]?: Scope }
+
+export function createContext<ContextValueType extends object | null>(
+  rootComponentName: string,
+  defaultContext?: ContextValueType
+): readonly [
+  (props: ContextValueType & { children: React.ReactNode }) => React.JSX.Element,
+  (consumerName: string) => Exclude<ContextValueType | undefined, undefined>,
+] {
+  const Context = React.createContext<ContextValueType | undefined>(defaultContext)
+
+  function Provider(props: ContextValueType & { children: React.ReactNode }) {
+    const { children, ...context } = props
+    // Only re-memoize when prop values change
+
+    const value = React.useMemo(() => context, Object.values(context)) as ContextValueType
+    return <Context.Provider value={value}>{children}</Context.Provider>
+  }
+
+  function useContext(consumerName: string): Exclude<typeof context, undefined> {
+    const context = React.useContext(Context)
+    if (context) return context as any
+    if (defaultContext !== undefined) return defaultContext as any
+    // if a defaultContext wasn't specified, it's a required context.
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``)
+  }
+
+  return [Provider, useContext] as const
+}
+
+/* -------------------------------------------------------------------------------------------------
+ * createContextScope
+ * -----------------------------------------------------------------------------------------------*/
+
+type ScopeHook = (scope: Scope) => { [__scopeProp: string]: Scope }
+
+export type Scope<C = any> = { [scopeName: string]: React.Context<C>[] } | undefined
+
+export interface CreateScope {
+  scopeName: string
+  (): ScopeHook
+}
+
+export function createContextScope(
+  scopeName: string,
+  createContextScopeDeps: CreateScope[] = []
+): readonly [
+  <ContextValueType extends object | null>(
+    rootComponentName: string,
+    defaultContext?: ContextValueType
+  ) => readonly [
+    (
+      props: ContextValueType & {
+        scope: Scope<ContextValueType>
+        children: React.ReactNode
+      }
+    ) => import('react/jsx-runtime').JSX.Element,
+    (
+      consumerName: string,
+      scope: Scope<ContextValueType | undefined>,
+      options?: {
+        warn?: boolean
+        fallback?: Partial<ContextValueType>
+      }
+    ) => ContextValueType,
+  ],
+  CreateScope,
+] {
+  let defaultContexts: any[] = []
+
+  /* -----------------------------------------------------------------------------------------------
+   * createContext
+   * ---------------------------------------------------------------------------------------------*/
+
+  function createContext<ContextValueType extends object | null>(
+    rootComponentName: string,
+    defaultContext?: ContextValueType
+  ) {
+    const BaseContext = React.createContext<ContextValueType | undefined>(defaultContext)
+    const index = defaultContexts.length
+    defaultContexts = [...defaultContexts, defaultContext]
+
+    function Provider(
+      props: ContextValueType & {
+        scope: Scope<ContextValueType>
+        children: React.ReactNode
+      }
+    ) {
+      const { scope, children, ...context } = props
+      const Context = scope?.[scopeName]?.[index] || BaseContext
+      // Only re-memoize when prop values change
+
+      const value = React.useMemo(
+        () => context,
+        Object.values(context)
+      ) as ContextValueType
+      return <Context.Provider value={value}>{children}</Context.Provider>
+    }
+
+    function useContext(
+      consumerName: string,
+      scope: Scope<ContextValueType | undefined>,
+      options?: {
+        warn?: boolean
+        fallback?: Partial<ContextValueType>
+      }
+    ) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext
+      const context = React.useContext(Context)
+      if (context) return context
+      // if a defaultContext wasn't specified, it's a required context.
+      if (defaultContext !== undefined) return defaultContext
+      const missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``
+      // fallback can be given per-hook as well
+      if (options?.fallback) {
+        if (options?.warn !== false) {
+          console.warn(missingContextMessage)
+        }
+        return options.fallback as ContextValueType
+      }
+      throw new Error(missingContextMessage)
+    }
+
+    return [Provider, useContext] as const
+  }
+
+  /* -----------------------------------------------------------------------------------------------
+   * createScope
+   * ---------------------------------------------------------------------------------------------*/
+
+  const createScope: CreateScope = () => {
+    const scopeContexts = defaultContexts.map((defaultContext) => {
+      return React.createContext(defaultContext)
+    })
+    return function useScope(scope: Scope) {
+      const contexts = scope?.[scopeName] || scopeContexts
+      return React.useMemo(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts]
+      )
+    }
+  }
+
+  createScope.scopeName = scopeName
+
+  return [
+    createContext,
+    composeContextScopes(createScope, ...createContextScopeDeps),
+  ] as const
+}
+
+/* -------------------------------------------------------------------------------------------------
+ * composeContextScopes
+ * -----------------------------------------------------------------------------------------------*/
+
+function composeContextScopes(...scopes: CreateScope[]) {
+  const baseScope = scopes[0]
+  if (scopes.length === 1) return baseScope
+
+  const createScope: CreateScope = () => {
+    const scopeHooks = scopes.map((createScope) => ({
+      useScope: createScope(),
+      scopeName: createScope.scopeName,
+    }))
+
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes, { useScope, scopeName }) => {
+        // We are calling a hook inside a callback which React warns against to avoid inconsistent
+        // renders, however, scoping doesn't have render side effects so we ignore the rule.
+
+        const scopeProps = useScope(overrideScopes)
+        const currentScope = scopeProps[`__scope${scopeName}`]
+        return { ...nextScopes, ...currentScope }
+      }, {})
+
+      return React.useMemo(
+        () => ({ [`__scope${baseScope.scopeName}`]: nextScopes }),
+        [nextScopes]
+      )
+    }
+  }
+
+  createScope.scopeName = baseScope.scopeName
+  return createScope
+}
+
+/* -----------------------------------------------------------------------------------------------*/

package/src/index.ts

@@ -0,0 +1 @@
+export * from './create-context'

package/types/create-context.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+export type ScopedProps<
+	P,
+	K extends string
+> = P & { [Key in `__scope${K}`]? : Scope };
+export declare function createContext<ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType): readonly [(props: ContextValueType & {
+	children: React.ReactNode;
+}) => React.JSX.Element, (consumerName: string) => Exclude<ContextValueType | undefined, undefined>];
+type ScopeHook = (scope: Scope) => {
+	[__scopeProp: string]: Scope;
+};
+export type Scope<C = any> = {
+	[scopeName: string]: React.Context<C>[];
+} | undefined;
+export interface CreateScope {
+	scopeName: string;
+	(): ScopeHook;
+}
+export declare function createContextScope(scopeName: string, createContextScopeDeps?: CreateScope[]): readonly [<ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType) => readonly [(props: ContextValueType & {
+	scope: Scope<ContextValueType>;
+	children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element, (consumerName: string, scope: Scope<ContextValueType | undefined>, options?: {
+	warn?: boolean;
+	fallback?: Partial<ContextValueType>;
+}) => ContextValueType], CreateScope];
+export {};
+
+//# sourceMappingURL=create-context.d.ts.map

package/types/create-context.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAGA,YAAY,WAAW;AAEvB,YAAY;CAAY;CAAG;IAAoB,OAAO,iBAAiB,QAAO;AAE9E,OAAO,iBAAS,cAAc,wCAC5B,2BACA,iBAAiB,8BAEhB,OAAO,mBAAmB;CAAE,UAAU,MAAM;MAAgB,MAAM,IAAI,UACtE,yBAAyB,QAAQ;KA2B/B,aAAa,OAAO,UAAU;wBAAyB;;AAE5D,YAAY,MAAM,WAAW;sBAAuB,MAAM,QAAQ;;AAElE,iBAAiB,YAAY;CAC3B;KACI;;AAGN,OAAO,iBAAS,mBACd,mBACA,yBAAwB,2BAEvB,wCACC,2BACA,iBAAiB,gCAGf,OAAO,mBAAmB;CACxB,OAAO,MAAM;CACb,UAAU,MAAM;aAER,mCAEV,sBACA,OAAO,MAAM,+BACb,UAAU;CACR;CACA,WAAW,QAAQ;MAElB,mBAEP",
+  "names": [],
+  "sources": [
+    "src/create-context.tsx"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// from radix\n// https://github.com/radix-ui/primitives/blob/main/packages/react/context/src/createContext.tsx\n\nimport * as React from 'react'\n\nexport type ScopedProps<P, K extends string> = P & { [Key in `__scope${K}`]?: Scope }\n\nexport function createContext<ContextValueType extends object | null>(\n  rootComponentName: string,\n  defaultContext?: ContextValueType\n): readonly [\n  (props: ContextValueType & { children: React.ReactNode }) => React.JSX.Element,\n  (consumerName: string) => Exclude<ContextValueType | undefined, undefined>,\n] {\n  const Context = React.createContext<ContextValueType | undefined>(defaultContext)\n\n  function Provider(props: ContextValueType & { children: React.ReactNode }) {\n    const { children, ...context } = props\n    // Only re-memoize when prop values change\n\n    const value = React.useMemo(() => context, Object.values(context)) as ContextValueType\n    return <Context.Provider value={value}>{children}</Context.Provider>\n  }\n\n  function useContext(consumerName: string): Exclude<typeof context, undefined> {\n    const context = React.useContext(Context)\n    if (context) return context as any\n    if (defaultContext !== undefined) return defaultContext as any\n    // if a defaultContext wasn't specified, it's a required context.\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``)\n  }\n\n  return [Provider, useContext] as const\n}\n\n/* -------------------------------------------------------------------------------------------------\n * createContextScope\n * -----------------------------------------------------------------------------------------------*/\n\ntype ScopeHook = (scope: Scope) => { [__scopeProp: string]: Scope }\n\nexport type Scope<C = any> = { [scopeName: string]: React.Context<C>[] } | undefined\n\nexport interface CreateScope {\n  scopeName: string\n  (): ScopeHook\n}\n\nexport function createContextScope(\n  scopeName: string,\n  createContextScopeDeps: CreateScope[] = []\n): readonly [\n  <ContextValueType extends object | null>(\n    rootComponentName: string,\n    defaultContext?: ContextValueType\n  ) => readonly [\n    (\n      props: ContextValueType & {\n        scope: Scope<ContextValueType>\n        children: React.ReactNode\n      }\n    ) => import('react/jsx-runtime').JSX.Element,\n    (\n      consumerName: string,\n      scope: Scope<ContextValueType | undefined>,\n      options?: {\n        warn?: boolean\n        fallback?: Partial<ContextValueType>\n      }\n    ) => ContextValueType,\n  ],\n  CreateScope,\n] {\n  let defaultContexts: any[] = []\n\n  /* -----------------------------------------------------------------------------------------------\n   * createContext\n   * ---------------------------------------------------------------------------------------------*/\n\n  function createContext<ContextValueType extends object | null>(\n    rootComponentName: string,\n    defaultContext?: ContextValueType\n  ) {\n    const BaseContext = React.createContext<ContextValueType | undefined>(defaultContext)\n    const index = defaultContexts.length\n    defaultContexts = [...defaultContexts, defaultContext]\n\n    function Provider(\n      props: ContextValueType & {\n        scope: Scope<ContextValueType>\n        children: React.ReactNode\n      }\n    ) {\n      const { scope, children, ...context } = props\n      const Context = scope?.[scopeName]?.[index] || BaseContext\n      // Only re-memoize when prop values change\n\n      const value = React.useMemo(\n        () => context,\n        Object.values(context)\n      ) as ContextValueType\n      return <Context.Provider value={value}>{children}</Context.Provider>\n    }\n\n    function useContext(\n      consumerName: string,\n      scope: Scope<ContextValueType | undefined>,\n      options?: {\n        warn?: boolean\n        fallback?: Partial<ContextValueType>\n      }\n    ) {\n      const Context = scope?.[scopeName]?.[index] || BaseContext\n      const context = React.useContext(Context)\n      if (context) return context\n      // if a defaultContext wasn't specified, it's a required context.\n      if (defaultContext !== undefined) return defaultContext\n      const missingContextMessage = `\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``\n      // fallback can be given per-hook as well\n      if (options?.fallback) {\n        if (options?.warn !== false) {\n          console.warn(missingContextMessage)\n        }\n        return options.fallback as ContextValueType\n      }\n      throw new Error(missingContextMessage)\n    }\n\n    return [Provider, useContext] as const\n  }\n\n  /* -----------------------------------------------------------------------------------------------\n   * createScope\n   * ---------------------------------------------------------------------------------------------*/\n\n  const createScope: CreateScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext)\n    })\n    return function useScope(scope: Scope) {\n      const contexts = scope?.[scopeName] || scopeContexts\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      )\n    }\n  }\n\n  createScope.scopeName = scopeName\n\n  return [\n    createContext,\n    composeContextScopes(createScope, ...createContextScopeDeps),\n  ] as const\n}\n\n/* -------------------------------------------------------------------------------------------------\n * composeContextScopes\n * -----------------------------------------------------------------------------------------------*/\n\nfunction composeContextScopes(...scopes: CreateScope[]) {\n  const baseScope = scopes[0]\n  if (scopes.length === 1) return baseScope\n\n  const createScope: CreateScope = () => {\n    const scopeHooks = scopes.map((createScope) => ({\n      useScope: createScope(),\n      scopeName: createScope.scopeName,\n    }))\n\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes, { useScope, scopeName }) => {\n        // We are calling a hook inside a callback which React warns against to avoid inconsistent\n        // renders, however, scoping doesn't have render side effects so we ignore the rule.\n\n        const scopeProps = useScope(overrideScopes)\n        const currentScope = scopeProps[`__scope${scopeName}`]\n        return { ...nextScopes, ...currentScope }\n      }, {})\n\n      return React.useMemo(\n        () => ({ [`__scope${baseScope.scopeName}`]: nextScopes }),\n        [nextScopes]\n      )\n    }\n  }\n\n  createScope.scopeName = baseScope.scopeName\n  return createScope\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./create-context";
+
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc",
+  "names": [],
+  "sources": [
+    "src/index.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "export * from './create-context'\n"
+  ]
+}