@hanzogui/create-context 2.0.0

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,130 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), 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),
+  import_jsx_runtime = require("react/jsx-runtime");
+function createContext(rootComponentName, defaultContext) {
+  const Context = React.createContext(defaultContext);
+  function Provider(props) {
+    const {
+        children,
+        ...context
+      } = props,
+      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),
+      index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      const {
+          scope,
+          children,
+          ...context
+        } = props,
+        Context = scope?.[scopeName]?.[index] || BaseContext,
+        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,
+        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) return options?.warn !== !1 && console.warn(missingContextMessage), options.fallback;
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map(defaultContext => React.createContext(defaultContext));
+    return function (scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(() => ({
+        [`__scope${scopeName}`]: {
+          ...scope,
+          [scopeName]: contexts
+        }
+      }), [scope, contexts]);
+    };
+  };
+  return createScope.scopeName = scopeName, [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 (overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, {
+        useScope,
+        scopeName
+      }) => {
+        const currentScope = useScope(overrideScopes)[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(() => ({
+        [`__scope${baseScope.scopeName}`]: nextScopes
+      }), [nextScopes]);
+    };
+  };
+  return createScope.scopeName = baseScope.scopeName, createScope;
+}

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

@@ -0,0 +1,151 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), 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"),
+  React = __toESM(require("react"), 1);
+function createContext(rootComponentName, defaultContext) {
+  var Context = /* @__PURE__ */React.createContext(defaultContext);
+  function Provider(props) {
+    var {
+        children,
+        ...context
+      } = props,
+      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] : [],
+    defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    var BaseContext = /* @__PURE__ */React.createContext(defaultContext),
+      index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      var _scope_scopeName,
+        {
+          scope,
+          children,
+          ...context
+        } = props,
+        Context = (scope == null || (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext,
+        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,
+        Context = (scope == null || (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext,
+        context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      var missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options?.fallback) return options?.warn !== !1 && console.warn(missingContextMessage), 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 (scope) {
+      var contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(function () {
+        return {
+          [`__scope${scopeName}`]: {
+            ...scope,
+            [scopeName]: contexts
+          }
+        };
+      }, [scope, contexts]);
+    };
+  };
+  return createScope.scopeName = scopeName, [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 (overrideScopes) {
+      var nextScopes = scopeHooks.reduce(function (nextScopes2, param) {
+        var {
+            useScope,
+            scopeName
+          } = param,
+          scopeProps = useScope(overrideScopes),
+          currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(function () {
+        return {
+          [`__scope${baseScope.scopeName}`]: nextScopes
+        };
+      }, [nextScopes]);
+    };
+  };
+  return createScope.scopeName = baseScope.scopeName, 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","contexts"],"sources":["../../src/create-context.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/index.cjs

@@ -0,0 +1,18 @@
+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)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  },
+  __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), 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,21 @@
+"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)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  },
+  __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), 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,95 @@
+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,
+      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),
+      index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      const {
+          scope,
+          children,
+          ...context
+        } = props,
+        Context = scope?.[scopeName]?.[index] || BaseContext,
+        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,
+        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) return options?.warn !== !1 && console.warn(missingContextMessage), options.fallback;
+      throw new Error(missingContextMessage);
+    }
+    return [Provider, useContext];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map(defaultContext => React.createContext(defaultContext));
+    return function (scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(() => ({
+        [`__scope${scopeName}`]: {
+          ...scope,
+          [scopeName]: contexts
+        }
+      }), [scope, contexts]);
+    };
+  };
+  return createScope.scopeName = scopeName, [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 (overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, {
+        useScope,
+        scopeName
+      }) => {
+        const currentScope = useScope(overrideScopes)[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(() => ({
+        [`__scope${baseScope.scopeName}`]: nextScopes
+      }), [nextScopes]);
+    };
+  };
+  return createScope.scopeName = baseScope.scopeName, 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","contexts","composeContextScopes","scopes","baseScope","scopeHooks","createScope2","useScope","overrideScopes","nextScopes","reduce","nextScopes2","currentScope"],"sources":["../../src/create-context.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,113 @@
+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,
+      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] : [],
+    defaultContexts = [];
+  function createContext2(rootComponentName, defaultContext) {
+    var BaseContext = /* @__PURE__ */React.createContext(defaultContext),
+      index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    function Provider(props) {
+      var _scope_scopeName,
+        {
+          scope,
+          children,
+          ...context
+        } = props,
+        Context = (scope == null || (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext,
+        value = React.useMemo(function () {
+          return context;
+        }, Object.values(context));
+      return /* @__PURE__ */_jsx(Context.Provider, {
+        value,
+        children
+      });
+    }
+    function useContext(consumerName, scope, options) {
+      var _scope_scopeName,
+        Context = (scope == null || (_scope_scopeName = scope[scopeName]) === null || _scope_scopeName === void 0 ? void 0 : _scope_scopeName[index]) || BaseContext,
+        context = React.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      var missingContextMessage = `\`${consumerName}\` must be used within \`${rootComponentName}\``;
+      if (options?.fallback) return options?.warn !== !1 && console.warn(missingContextMessage), 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 (scope) {
+      var contexts = scope?.[scopeName] || scopeContexts;
+      return React.useMemo(function () {
+        return {
+          [`__scope${scopeName}`]: {
+            ...scope,
+            [scopeName]: contexts
+          }
+        };
+      }, [scope, contexts]);
+    };
+  };
+  return createScope.scopeName = scopeName, [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 (overrideScopes) {
+      var nextScopes = scopeHooks.reduce(function (nextScopes2, param) {
+        var {
+            useScope,
+            scopeName
+          } = param,
+          scopeProps = useScope(overrideScopes),
+          currentScope = scopeProps[`__scope${scopeName}`];
+        return {
+          ...nextScopes2,
+          ...currentScope
+        };
+      }, {});
+      return React.useMemo(function () {
+        return {
+          [`__scope${baseScope.scopeName}`]: nextScopes
+        };
+      }, [nextScopes]);
+    };
+  };
+  return createScope.scopeName = baseScope.scopeName, 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","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",
+  "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": "hanzo-gui-build",
+    "watch": "hanzo-gui-build --watch",
+    "clean": "hanzo-gui-build clean",
+    "clean:build": "hanzo-gui-build clean:build"
+  },
+  "devDependencies": {
+    "@hanzogui/build": "workspace:*",
+    "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"
+  ]
+}