@makeswift/runtime 0.28.10-canary.8 → 0.29.0-canary.19

package/dist/cjs/runtimes/react/css-runtime/components/styles-context-provider.js

@@ -0,0 +1,54 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var styles_context_provider_exports = {};
+__export(styles_context_provider_exports, {
+  StylesContext: () => StylesContext,
+  StylesContextProvider: () => StylesContextProvider
+});
+module.exports = __toCommonJS(styles_context_provider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+const StylesContext = (0, import_react.createContext)(void 0);
+function StylesContextProvider({
+  children,
+  classNamePrefix,
+  enableCssReset,
+  stylesRegistry,
+  shouldRenderStyleElements
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    StylesContext.Provider,
+    {
+      value: {
+        classNamePrefix,
+        enableCssReset,
+        stylesRegistry,
+        shouldRenderStyleElements
+      },
+      children
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StylesContext,
+  StylesContextProvider
+});
+//# sourceMappingURL=styles-context-provider.js.map

package/dist/cjs/runtimes/react/css-runtime/components/styles-context-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/components/styles-context-provider.tsx"],"sourcesContent":["'use client'\n\nimport { createContext, PropsWithChildren } from 'react'\nimport { StylesRegistry } from '../styles-registry'\n\nexport type StylesContextValue = {\n  classNamePrefix: string\n  enableCssReset: boolean\n  stylesRegistry: StylesRegistry\n\n  /**\n   * By default, Makeswift-generated `<style>` elements are placed in JSX alongside the components that use them\n   * (note that in practice, React may hoist `<style>`s into the document `<head>` such that they don't appear in the\n   * `<body>` at all).\n   *\n   * This setting allows you to disable the automatic rendering of Makeswift-generated `<style>` elements. The expectation\n   * is that, when `shouldRenderStyleElements` is `false`, you will access generated styles from the Makeswift styles registry\n   * and handle applying them manually.\n   */\n  shouldRenderStyleElements: boolean\n}\n\nexport const StylesContext = createContext<StylesContextValue | undefined>(undefined)\n\nexport function StylesContextProvider({\n  children,\n  classNamePrefix,\n  enableCssReset,\n  stylesRegistry,\n  shouldRenderStyleElements,\n}: PropsWithChildren<StylesContextValue>) {\n  return (\n    <StylesContext.Provider\n      value={{\n        classNamePrefix,\n        enableCssReset,\n        stylesRegistry,\n        shouldRenderStyleElements,\n      }}\n    >\n      {children}\n    </StylesContext.Provider>\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCI;AA9BJ,mBAAiD;AAoB1C,MAAM,oBAAgB,4BAA8C,MAAS;AAE7E,SAAS,sBAAsB;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA0C;AACxC,SACE;AAAA,IAAC,cAAc;AAAA,IAAd;AAAA,MACC,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,MAEC;AAAA;AAAA,EACH;AAEJ;","names":[]}

package/dist/cjs/runtimes/react/css-runtime/constants.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_CSS_CLASS_NAME_PREFIX: () => DEFAULT_CSS_CLASS_NAME_PREFIX,
+  DEFAULT_CSS_PRECEDENCE: () => DEFAULT_CSS_PRECEDENCE,
+  DEFAULT_CSS_RESET_ENABLED: () => DEFAULT_CSS_RESET_ENABLED,
+  DEFAULT_SHOULD_RENDER_STYLE_ELEMENTS: () => DEFAULT_SHOULD_RENDER_STYLE_ELEMENTS
+});
+module.exports = __toCommonJS(constants_exports);
+var import_types = require("./types");
+const DEFAULT_CSS_CLASS_NAME_PREFIX = "ms";
+const DEFAULT_CSS_RESET_ENABLED = true;
+const DEFAULT_CSS_PRECEDENCE = import_types.MakeswiftStylePrecedence.MEDIUM;
+const DEFAULT_SHOULD_RENDER_STYLE_ELEMENTS = true;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CSS_CLASS_NAME_PREFIX,
+  DEFAULT_CSS_PRECEDENCE,
+  DEFAULT_CSS_RESET_ENABLED,
+  DEFAULT_SHOULD_RENDER_STYLE_ELEMENTS
+});
+//# sourceMappingURL=constants.js.map

package/dist/cjs/runtimes/react/css-runtime/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/runtimes/react/css-runtime/constants.ts"],"sourcesContent":["import { MakeswiftStylePrecedence } from './types'\n\nexport const DEFAULT_CSS_CLASS_NAME_PREFIX = 'ms'\nexport const DEFAULT_CSS_RESET_ENABLED = true\nexport const DEFAULT_CSS_PRECEDENCE = MakeswiftStylePrecedence.MEDIUM\nexport const DEFAULT_SHOULD_RENDER_STYLE_ELEMENTS = true\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyC;AAElC,MAAM,gCAAgC;AACtC,MAAM,4BAA4B;AAClC,MAAM,yBAAyB,sCAAyB;AACxD,MAAM,uCAAuC;","names":[]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-base-styles.js

@@ -0,0 +1,67 @@
+"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 use_base_styles_exports = {};
+__export(use_base_styles_exports, {
+  useBaseStyles: () => useBaseStyles
+});
+module.exports = __toCommonJS(use_base_styles_exports);
+var import_use_styles_context = require("./use-styles-context");
+var import_serialize_css = require("../serialize-css");
+var import_types = require("../types");
+var import_react = __toESM(require("react"));
+var import_makeswift_style = require("../components/makeswift-style");
+function useBaseStyles({ styles }) {
+  const { stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  const { content: rawContent, contentHash } = (0, import_serialize_css.toRawCss)([styles]);
+  let styleData = stylesRegistry.getBaseStyles().get(contentHash);
+  if (styleData == null) {
+    const css = (0, import_serialize_css.processCss)({ content: rawContent });
+    styleData = {
+      css,
+      cssObject: styles,
+      contentHash
+    };
+    stylesRegistry.setBaseStyles(styleData);
+  }
+  const href = `makeswift-base-styles-${contentHash}`;
+  const styleElement = import_react.default.createElement(import_makeswift_style.MakeswiftStyle, {
+    key: contentHash,
+    href,
+    css: styleData.css,
+    precedence: import_types.MakeswiftStylePrecedence.HIGH
+  });
+  return {
+    styleElement
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useBaseStyles
+});
+//# sourceMappingURL=use-base-styles.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-base-styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-base-styles.ts"],"sourcesContent":["import { type CSSObject } from '@emotion/serialize'\nimport { useStylesContext } from './use-styles-context'\nimport { processCss, toRawCss } from '../serialize-css'\nimport { MakeswiftStylePrecedence } from '../types'\nimport React from 'react'\nimport { MakeswiftStyle } from '../components/makeswift-style'\n\nexport function useBaseStyles({ styles }: { styles: CSSObject }) {\n  const { stylesRegistry } = useStylesContext()\n  const { content: rawContent, contentHash } = toRawCss([styles])\n  let styleData = stylesRegistry.getBaseStyles().get(contentHash)\n  if (styleData == null) {\n    const css = processCss({ content: rawContent })\n    styleData = {\n      css,\n      cssObject: styles,\n      contentHash,\n    }\n    stylesRegistry.setBaseStyles(styleData)\n  }\n  const href = `makeswift-base-styles-${contentHash}`\n  const styleElement = React.createElement(MakeswiftStyle, {\n    key: contentHash,\n    href: href,\n    css: styleData.css,\n    precedence: MakeswiftStylePrecedence.HIGH,\n  })\n  return {\n    styleElement,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,gCAAiC;AACjC,2BAAqC;AACrC,mBAAyC;AACzC,mBAAkB;AAClB,6BAA+B;AAExB,SAAS,cAAc,EAAE,OAAO,GAA0B;AAC/D,QAAM,EAAE,eAAe,QAAI,4CAAiB;AAC5C,QAAM,EAAE,SAAS,YAAY,YAAY,QAAI,+BAAS,CAAC,MAAM,CAAC;AAC9D,MAAI,YAAY,eAAe,cAAc,EAAE,IAAI,WAAW;AAC9D,MAAI,aAAa,MAAM;AACrB,UAAM,UAAM,iCAAW,EAAE,SAAS,WAAW,CAAC;AAC9C,gBAAY;AAAA,MACV;AAAA,MACA,WAAW;AAAA,MACX;AAAA,IACF;AACA,mBAAe,cAAc,SAAS;AAAA,EACxC;AACA,QAAM,OAAO,yBAAyB,WAAW;AACjD,QAAM,eAAe,aAAAA,QAAM,cAAc,uCAAgB;AAAA,IACvD,KAAK;AAAA,IACL;AAAA,IACA,KAAK,UAAU;AAAA,IACf,YAAY,sCAAyB;AAAA,EACvC,CAAC;AACD,SAAO;AAAA,IACL;AAAA,EACF;AACF;","names":["React"]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-controlled-styles.js

@@ -0,0 +1,79 @@
+"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 use_controlled_styles_exports = {};
+__export(use_controlled_styles_exports, {
+  useControlledStyles: () => useControlledStyles
+});
+module.exports = __toCommonJS(use_controlled_styles_exports);
+var import_react = __toESM(require("react"));
+var import_controlled_styles = require("../components/controlled-styles");
+var import_use_styles_context = require("./use-styles-context");
+var import_stylesheet_engine = require("../stylesheet-engine");
+var import_use_document_context = require("../../hooks/use-document-context");
+function useControlledStyles({ namespace }) {
+  const { classNamePrefix, stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  const documentKey = (0, import_use_document_context.useDocumentKey)();
+  if (documentKey == null) {
+    throw new Error("Root document key not found when attempting to use controlled styles");
+  }
+  const getStylesheet = (0, import_react.useCallback)(
+    ({ breakpointsData, elementKey, propPathComponents }) => {
+      const onDefineStyle = (definedStyle) => {
+        stylesRegistry.setControlledStyle({
+          namespace,
+          className: definedStyle.className,
+          data: {
+            ...definedStyle
+          }
+        });
+      };
+      return new import_stylesheet_engine.StylesheetEngine({
+        breakpointsData,
+        documentKey,
+        elementKey,
+        propPathComponents,
+        onDefineStyle,
+        classNamePrefix
+      });
+    },
+    [classNamePrefix, stylesRegistry, namespace, documentKey]
+  );
+  const styleElements = import_react.default.createElement(import_controlled_styles.ControlledStyles, {
+    classNameToStyles: stylesRegistry.getControlledStyles(namespace)
+  });
+  return {
+    getStylesheet,
+    styleElements
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useControlledStyles
+});
+//# sourceMappingURL=use-controlled-styles.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-controlled-styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-controlled-styles.ts"],"sourcesContent":["import React, { useCallback } from 'react'\nimport { ControlledStyles } from '../components/controlled-styles'\nimport { ControlledStyleData, GetStylesheet } from '../types'\nimport { useStylesContext } from './use-styles-context'\nimport { StylesheetEngine } from '../stylesheet-engine'\nimport { useDocumentKey } from '../../hooks/use-document-context'\n\nexport function useControlledStyles({ namespace }: { namespace: string }) {\n  const { classNamePrefix, stylesRegistry } = useStylesContext()\n  const documentKey = useDocumentKey()\n  if (documentKey == null) {\n    throw new Error('Root document key not found when attempting to use controlled styles')\n  }\n\n  const getStylesheet = useCallback<GetStylesheet>(\n    ({ breakpointsData, elementKey, propPathComponents }) => {\n      const onDefineStyle = (definedStyle: ControlledStyleData) => {\n        stylesRegistry.setControlledStyle({\n          namespace,\n          className: definedStyle.className,\n          data: {\n            ...definedStyle,\n          },\n        })\n      }\n      return new StylesheetEngine({\n        breakpointsData,\n        documentKey,\n        elementKey,\n        propPathComponents,\n        onDefineStyle,\n        classNamePrefix,\n      })\n    },\n    [classNamePrefix, stylesRegistry, namespace, documentKey],\n  )\n\n  const styleElements = React.createElement(ControlledStyles, {\n    classNameToStyles: stylesRegistry.getControlledStyles(namespace),\n  })\n\n  return {\n    getStylesheet,\n    styleElements,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAmC;AACnC,+BAAiC;AAEjC,gCAAiC;AACjC,+BAAiC;AACjC,kCAA+B;AAExB,SAAS,oBAAoB,EAAE,UAAU,GAA0B;AACxE,QAAM,EAAE,iBAAiB,eAAe,QAAI,4CAAiB;AAC7D,QAAM,kBAAc,4CAAe;AACnC,MAAI,eAAe,MAAM;AACvB,UAAM,IAAI,MAAM,sEAAsE;AAAA,EACxF;AAEA,QAAM,oBAAgB;AAAA,IACpB,CAAC,EAAE,iBAAiB,YAAY,mBAAmB,MAAM;AACvD,YAAM,gBAAgB,CAAC,iBAAsC;AAC3D,uBAAe,mBAAmB;AAAA,UAChC;AAAA,UACA,WAAW,aAAa;AAAA,UACxB,MAAM;AAAA,YACJ,GAAG;AAAA,UACL;AAAA,QACF,CAAC;AAAA,MACH;AACA,aAAO,IAAI,0CAAiB;AAAA,QAC1B;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA,CAAC,iBAAiB,gBAAgB,WAAW,WAAW;AAAA,EAC1D;AAEA,QAAM,gBAAgB,aAAAA,QAAM,cAAc,2CAAkB;AAAA,IAC1D,mBAAmB,eAAe,oBAAoB,SAAS;AAAA,EACjE,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":["React"]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-css-reset.js

@@ -0,0 +1,70 @@
+"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 use_css_reset_exports = {};
+__export(use_css_reset_exports, {
+  useCssReset: () => useCssReset
+});
+module.exports = __toCommonJS(use_css_reset_exports);
+var import_use_styles_context = require("./use-styles-context");
+var import_serialize_css = require("../serialize-css");
+var import_types = require("../types");
+var import_makeswift_style = require("../components/makeswift-style");
+var import_react = __toESM(require("react"));
+function useCssReset({ styles }) {
+  const { enableCssReset, stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  if (!enableCssReset)
+    return { styleElement: null };
+  const { content: rawContent, contentHash } = (0, import_serialize_css.toRawCss)(styles);
+  let styleData = stylesRegistry.getCssResets().get(contentHash);
+  if (styleData == null) {
+    const css2 = (0, import_serialize_css.processCss)({ content: rawContent });
+    styleData = {
+      css: css2,
+      cssObjects: styles,
+      contentHash
+    };
+    stylesRegistry.setCssReset(styleData);
+  }
+  const css = (0, import_serialize_css.processCss)({ content: rawContent });
+  const href = `makeswift-css-reset-${contentHash}`;
+  const styleElement = import_react.default.createElement(import_makeswift_style.MakeswiftStyle, {
+    key: contentHash,
+    href,
+    css,
+    precedence: import_types.MakeswiftStylePrecedence.RESET
+  });
+  return {
+    styleElement
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCssReset
+});
+//# sourceMappingURL=use-css-reset.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-css-reset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-css-reset.ts"],"sourcesContent":["import { type CSSObject } from '@emotion/serialize'\nimport { useStylesContext } from './use-styles-context'\nimport { processCss, toRawCss } from '../serialize-css'\nimport { MakeswiftStylePrecedence } from '../types'\nimport { MakeswiftStyle } from '../components/makeswift-style'\nimport React from 'react'\n\nexport function useCssReset({ styles }: { styles: Array<CSSObject> }) {\n  const { enableCssReset, stylesRegistry } = useStylesContext()\n  if (!enableCssReset) return { styleElement: null }\n  const { content: rawContent, contentHash } = toRawCss(styles)\n  let styleData = stylesRegistry.getCssResets().get(contentHash)\n  if (styleData == null) {\n    const css = processCss({ content: rawContent })\n    styleData = {\n      css,\n      cssObjects: styles,\n      contentHash,\n    }\n    stylesRegistry.setCssReset(styleData)\n  }\n  const css = processCss({ content: rawContent })\n  const href = `makeswift-css-reset-${contentHash}`\n\n  const styleElement = React.createElement(MakeswiftStyle, {\n    key: contentHash,\n    href: href,\n    css,\n    precedence: MakeswiftStylePrecedence.RESET,\n  })\n  return {\n    styleElement,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,gCAAiC;AACjC,2BAAqC;AACrC,mBAAyC;AACzC,6BAA+B;AAC/B,mBAAkB;AAEX,SAAS,YAAY,EAAE,OAAO,GAAiC;AACpE,QAAM,EAAE,gBAAgB,eAAe,QAAI,4CAAiB;AAC5D,MAAI,CAAC;AAAgB,WAAO,EAAE,cAAc,KAAK;AACjD,QAAM,EAAE,SAAS,YAAY,YAAY,QAAI,+BAAS,MAAM;AAC5D,MAAI,YAAY,eAAe,aAAa,EAAE,IAAI,WAAW;AAC7D,MAAI,aAAa,MAAM;AACrB,UAAMA,WAAM,iCAAW,EAAE,SAAS,WAAW,CAAC;AAC9C,gBAAY;AAAA,MACV,KAAAA;AAAA,MACA,YAAY;AAAA,MACZ;AAAA,IACF;AACA,mBAAe,YAAY,SAAS;AAAA,EACtC;AACA,QAAM,UAAM,iCAAW,EAAE,SAAS,WAAW,CAAC;AAC9C,QAAM,OAAO,uBAAuB,WAAW;AAE/C,QAAM,eAAe,aAAAC,QAAM,cAAc,uCAAgB;AAAA,IACvD,KAAK;AAAA,IACL;AAAA,IACA;AAAA,IACA,YAAY,sCAAyB;AAAA,EACvC,CAAC;AACD,SAAO;AAAA,IACL;AAAA,EACF;AACF;","names":["css","React"]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-dynamic-browser-style-updates.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_dynamic_browser_style_updates_exports = {};
+__export(use_dynamic_browser_style_updates_exports, {
+  useDynamicBrowserStyleUpdates: () => useDynamicBrowserStyleUpdates
+});
+module.exports = __toCommonJS(use_dynamic_browser_style_updates_exports);
+var import_react = require("react");
+var import_browser_dynamic_styles_bridge = require("../browser-dynamic-styles-bridge");
+var import_style_element_updater = require("../style-element-updater");
+function useDynamicBrowserStyleUpdates(registry) {
+  (0, import_react.useEffect)(() => {
+    const applier = new import_style_element_updater.StyleElementUpdater();
+    const bridge = new import_browser_dynamic_styles_bridge.BrowserDynamicStylesBridge(registry, applier);
+    return () => {
+      bridge.dispose();
+      applier.dispose?.();
+    };
+  }, [registry]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDynamicBrowserStyleUpdates
+});
+//# sourceMappingURL=use-dynamic-browser-style-updates.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-dynamic-browser-style-updates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-dynamic-browser-style-updates.ts"],"sourcesContent":["import { useEffect } from 'react'\nimport { StylesRegistry } from '../styles-registry'\nimport { BrowserDynamicStylesBridge } from '../browser-dynamic-styles-bridge'\nimport { StyleElementUpdater } from '../style-element-updater'\nimport { type BrowserStyleApplier } from '../types'\n\nexport function useDynamicBrowserStyleUpdates(registry: StylesRegistry) {\n  useEffect(() => {\n    const applier: BrowserStyleApplier = new StyleElementUpdater()\n    const bridge = new BrowserDynamicStylesBridge(registry, applier)\n\n    return () => {\n      bridge.dispose()\n      applier.dispose?.()\n    }\n  }, [registry])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAE1B,2CAA2C;AAC3C,mCAAoC;AAG7B,SAAS,8BAA8B,UAA0B;AACtE,8BAAU,MAAM;AACd,UAAM,UAA+B,IAAI,iDAAoB;AAC7D,UAAM,SAAS,IAAI,gEAA2B,UAAU,OAAO;AAE/D,WAAO,MAAM;AACX,aAAO,QAAQ;AACf,cAAQ,UAAU;AAAA,IACpB;AAAA,EACF,GAAG,CAAC,QAAQ,CAAC;AACf;","names":[]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-keyframes.js

@@ -0,0 +1,64 @@
+"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 use_keyframes_exports = {};
+__export(use_keyframes_exports, {
+  useKeyframes: () => useKeyframes
+});
+module.exports = __toCommonJS(use_keyframes_exports);
+var import_utils = require("../utils");
+var import_react = __toESM(require("react"));
+var import_makeswift_style = require("../components/makeswift-style");
+var import_use_styles_context = require("./use-styles-context");
+function useKeyframes(cssBody) {
+  const { classNamePrefix, stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  const keyframesNamePrefix = `${classNamePrefix}-animation`;
+  const keyframesName = (0, import_utils.generateClassName)({
+    data: cssBody,
+    classNamePrefix: keyframesNamePrefix
+  });
+  const cssString = `@keyframes ${keyframesName} { ${cssBody} }`;
+  const styleData = {
+    keyframesName,
+    css: cssString
+  };
+  stylesRegistry.setKeyframes(styleData);
+  const styleElement = import_react.default.createElement(import_makeswift_style.MakeswiftStyle, {
+    href: keyframesName,
+    css: cssString
+  });
+  return {
+    keyframesName,
+    styleElement
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useKeyframes
+});
+//# sourceMappingURL=use-keyframes.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-keyframes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-keyframes.ts"],"sourcesContent":["import { generateClassName } from '../utils'\nimport React from 'react'\nimport { MakeswiftStyle } from '../components/makeswift-style'\nimport { useStylesContext } from './use-styles-context'\nimport { KeyframesData } from '../types'\n\nexport function useKeyframes(cssBody: string): {\n  keyframesName: string\n  styleElement: React.ReactElement\n} {\n  const { classNamePrefix, stylesRegistry } = useStylesContext()\n  const keyframesNamePrefix = `${classNamePrefix}-animation`\n  const keyframesName = generateClassName({\n    data: cssBody,\n    classNamePrefix: keyframesNamePrefix,\n  })\n  const cssString = `@keyframes ${keyframesName} { ${cssBody} }`\n  const styleData: KeyframesData = {\n    keyframesName,\n    css: cssString,\n  }\n  stylesRegistry.setKeyframes(styleData)\n\n  const styleElement = React.createElement(MakeswiftStyle, {\n    href: keyframesName,\n    css: cssString,\n  })\n\n  return {\n    keyframesName,\n    styleElement,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkC;AAClC,mBAAkB;AAClB,6BAA+B;AAC/B,gCAAiC;AAG1B,SAAS,aAAa,SAG3B;AACA,QAAM,EAAE,iBAAiB,eAAe,QAAI,4CAAiB;AAC7D,QAAM,sBAAsB,GAAG,eAAe;AAC9C,QAAM,oBAAgB,gCAAkB;AAAA,IACtC,MAAM;AAAA,IACN,iBAAiB;AAAA,EACnB,CAAC;AACD,QAAM,YAAY,cAAc,aAAa,MAAM,OAAO;AAC1D,QAAM,YAA2B;AAAA,IAC/B;AAAA,IACA,KAAK;AAAA,EACP;AACA,iBAAe,aAAa,SAAS;AAErC,QAAM,eAAe,aAAAA,QAAM,cAAc,uCAAgB;AAAA,IACvD,MAAM;AAAA,IACN,KAAK;AAAA,EACP,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":["React"]}

package/dist/cjs/runtimes/react/css-runtime/hooks/use-legacy-controlled-style.js

@@ -0,0 +1,78 @@
+"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 use_legacy_controlled_style_exports = {};
+__export(use_legacy_controlled_style_exports, {
+  useLegacyControlledStyle: () => useLegacyControlledStyle
+});
+module.exports = __toCommonJS(use_legacy_controlled_style_exports);
+var import_utils = require("../utils");
+var import_react = __toESM(require("react"));
+var import_use_styles_context = require("./use-styles-context");
+var import_controlled_styles = require("../components/controlled-styles");
+var import_serialize_css = require("../serialize-css");
+var import_use_document_context = require("../../hooks/use-document-context");
+function useLegacyControlledStyle(style, elementKey, propName) {
+  const { classNamePrefix, stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  const documentKey = (0, import_use_document_context.useDocumentKey)();
+  if (documentKey == null) {
+    throw new Error("Root document key not found when attempting to use legacy controlled styles");
+  }
+  const namespace = `${elementKey}-legacy-${propName}`;
+  const className = (0, import_utils.generateClassName)({
+    data: `${documentKey}-${elementKey}-${propName}`,
+    classNamePrefix
+  });
+  const { css, contentHash } = (0, import_serialize_css.toCssStatements)(style, className);
+  const data = {
+    className,
+    css,
+    cssObject: style,
+    contentHash,
+    elementKey,
+    joinedPropPath: propName,
+    onBoxModelChange: void 0
+  };
+  stylesRegistry.setControlledStyle({
+    namespace,
+    className,
+    data
+  });
+  const styleElement = import_react.default.createElement(import_controlled_styles.ControlledStyles, {
+    classNameToStyles: /* @__PURE__ */ new Map([[className, data]])
+  });
+  return {
+    className,
+    styleElement
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLegacyControlledStyle
+});
+//# sourceMappingURL=use-legacy-controlled-style.js.map

package/dist/cjs/runtimes/react/css-runtime/hooks/use-legacy-controlled-style.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/runtimes/react/css-runtime/hooks/use-legacy-controlled-style.ts"],"sourcesContent":["import { CSSObject } from '@emotion/serialize'\nimport { generateClassName } from '../utils'\nimport React from 'react'\nimport { useStylesContext } from './use-styles-context'\nimport { ControlledStyles } from '../components/controlled-styles'\nimport { toCssStatements } from '../serialize-css'\nimport { ControlledStyleData } from '../types'\nimport { useDocumentKey } from '../../hooks/use-document-context'\n\nexport function useLegacyControlledStyle(style: CSSObject, elementKey: string, propName: string) {\n  const { classNamePrefix, stylesRegistry } = useStylesContext()\n  const documentKey = useDocumentKey()\n  if (documentKey == null) {\n    throw new Error('Root document key not found when attempting to use legacy controlled styles')\n  }\n\n  /*\n    Namespaced separately from styles for modern control instances in order to avoid\n    unintentionally attempting to render the corresponding style elements twice.\n  */\n  const namespace = `${elementKey}-legacy-${propName}`\n  const className = generateClassName({\n    data: `${documentKey}-${elementKey}-${propName}`,\n    classNamePrefix,\n  })\n\n  const { css, contentHash } = toCssStatements(style, className)\n\n  const data: ControlledStyleData = {\n    className,\n    css,\n    cssObject: style,\n    contentHash,\n    elementKey,\n    joinedPropPath: propName,\n    onBoxModelChange: undefined,\n  }\n\n  stylesRegistry.setControlledStyle({\n    namespace,\n    className,\n    data,\n  })\n\n  const styleElement = React.createElement(ControlledStyles, {\n    classNameToStyles: new Map([[className, data]]),\n  })\n\n  return {\n    className,\n    styleElement,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAkC;AAClC,mBAAkB;AAClB,gCAAiC;AACjC,+BAAiC;AACjC,2BAAgC;AAEhC,kCAA+B;AAExB,SAAS,yBAAyB,OAAkB,YAAoB,UAAkB;AAC/F,QAAM,EAAE,iBAAiB,eAAe,QAAI,4CAAiB;AAC7D,QAAM,kBAAc,4CAAe;AACnC,MAAI,eAAe,MAAM;AACvB,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAMA,QAAM,YAAY,GAAG,UAAU,WAAW,QAAQ;AAClD,QAAM,gBAAY,gCAAkB;AAAA,IAClC,MAAM,GAAG,WAAW,IAAI,UAAU,IAAI,QAAQ;AAAA,IAC9C;AAAA,EACF,CAAC;AAED,QAAM,EAAE,KAAK,YAAY,QAAI,sCAAgB,OAAO,SAAS;AAE7D,QAAM,OAA4B;AAAA,IAChC;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,EACpB;AAEA,iBAAe,mBAAmB;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,eAAe,aAAAA,QAAM,cAAc,2CAAkB;AAAA,IACzD,mBAAmB,oBAAI,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC;AAAA,EAChD,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":["React"]}

package/dist/cjs/runtimes/react/{use-style.js → css-runtime/hooks/use-style.js}

@@ -28,45 +28,64 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var use_style_exports = {};
 __export(use_style_exports, {
-  serializedStyleClassName: () => serializedStyleClassName,
-  useStyle: () => useStyle,
-  useStyles: () => useStyles
+  composeStyles: () => composeStyles,
+  useStyle: () => useStyle
 });
 module.exports = __toCommonJS(use_style_exports);
+var import_utils = require("../utils");
 var import_react = __toESM(require("react"));
-var import_serialize2 = require("@emotion/serialize");
-var import_utils = require("@emotion/utils");
-var import_is_server = require("../../utils/is-server");
-var import_root_style_registry = require("./root-style-registry");
-const useInsertionEffectSpecifier = "useInsertionEffect";
-const useInsertionEffect = import_react.default[useInsertionEffectSpecifier] ?? import_react.default.useLayoutEffect;
+var import_clsx = __toESM(require("clsx"));
+var import_use_styles_context = require("./use-styles-context");
+var import_serialize_css = require("../serialize-css");
+var import_makeswift_style = require("../components/makeswift-style");
 function useStyle(style) {
-  const cache = (0, import_root_style_registry.useCache)();
-  const serialized = (0, import_serialize2.serializeStyles)([style], cache.registered);
-  (0, import_utils.registerStyles)(cache, serialized, false);
-  useUniversalInsertionEffect(() => {
-    (0, import_utils.insertStyles)(cache, serialized, false);
+  const { classNamePrefix, stylesRegistry } = (0, import_use_styles_context.useStylesContext)();
+  const className = (0, import_utils.generateClassName)({
+    data: JSON.stringify(style),
+    classNamePrefix
   });
-  return serializedStyleClassName(cache, serialized);
-}
-function useStyles(cache, styles) {
-  styles.forEach((s) => (0, import_utils.registerStyles)(cache, s, false));
-  useUniversalInsertionEffect(() => {
-    styles.forEach((s) => (0, import_utils.insertStyles)(cache, s, false));
+  let styleData = stylesRegistry.getUncontrolledClassStyles().get(className);
+  if (styleData == null) {
+    const { css } = (0, import_serialize_css.toCssStatements)(style, className);
+    styleData = {
+      className,
+      css,
+      cssObject: style
+    };
+    stylesRegistry.setUncontrolledClassStyle(styleData);
+  }
+  const styleElement = import_react.default.createElement(import_makeswift_style.MakeswiftStyle, {
+    key: className,
+    href: className,
+    css: styleData.css
   });
+  return {
+    className,
+    styleElement
+  };
 }
-function useUniversalInsertionEffect(effect) {
-  useInsertionEffect(effect);
-  if ((0, import_is_server.isServer)())
-    effect();
-}
-function serializedStyleClassName(cache, serialized) {
-  return `${cache.key}-${serialized.name}`;
+function composeStyles(...args) {
+  const classNames = [];
+  const styleElements = [];
+  args.forEach((arg) => {
+    if (arg == null)
+      return;
+    if (typeof arg === "string") {
+      classNames.push(arg);
+    } else {
+      classNames.push(arg.className);
+      styleElements.push(arg.styleElement);
+    }
+  });
+  const combinedClassName = (0, import_clsx.default)(classNames);
+  return {
+    className: combinedClassName,
+    styleElements
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  serializedStyleClassName,
-  useStyle,
-  useStyles
+  composeStyles,
+  useStyle
 });
 //# sourceMappingURL=use-style.js.map