@cyclone-ui/nextjs 0.0.0-stage → 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+![Cyclone UI's logo banner](https://public.storm-cdn.com/cyclone-ui/media/banner-1280x320-dark.gif)
+
+# Changelog for Cyclone UI - Nextjs
+
+## [0.0.2](https://github.com/storm-software/cyclone-ui/releases/tag/nextjs%400.0.2) (10/24/2026)
+
+### Features
+
+- **nextjs:** Added NextJS and Vite build packages, setup skills, and documentation updates ([2759b41c](https://github.com/storm-software/cyclone-ui/commit/2759b41c))
+
+### Updated Dependencies
+
+- Updated **state** to **v0.0.32**
+- Updated **tokens** to **v0.3.20**

package/LICENSE

@@ -0,0 +1,187 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction, and
+   distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by the
+   copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control with
+   that entity. For the purposes of this definition, "control" means (i) the
+   power, direct or indirect, to cause the direction or management of such
+   entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+   (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+   such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity exercising
+   permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation source, and
+   configuration files.
+
+   "Object" form shall mean any form resulting from mechanical transformation or
+   translation of a Source form, including but not limited to compiled object
+   code, generated documentation, and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or Object form,
+   made available under the License, as indicated by a copyright notice that is
+   included in or attached to the work (an example is provided in the Appendix
+   below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object form,
+   that is based on (or derived from) the Work and for which the editorial
+   revisions, annotations, elaborations, or other modifications represent, as a
+   whole, an original work of authorship. For the purposes of this License,
+   Derivative Works shall not include works that remain separable from, or
+   merely link (or bind by name) to the interfaces of, the Work and Derivative
+   Works thereof.
+
+   "Contribution" shall mean any work of authorship, including the original
+   version of the Work and any modifications or additions to that Work or
+   Derivative Works thereof, that is intentionally submitted to Licensor for
+   inclusion in the Work by the copyright owner or by an individual or Legal
+   Entity authorized to submit on behalf of the copyright owner. For the
+   purposes of this definition, "submitted" means any form of electronic,
+   verbal, or written communication sent to the Licensor or its representatives,
+   including but not limited to communication on electronic mailing lists,
+   source code control systems, and issue tracking systems that are managed by,
+   or on behalf of, the Licensor for the purpose of discussing and improving the
+   Work, but excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity on
+   behalf of whom a Contribution has been received by Licensor and subsequently
+   incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+   reproduce, prepare Derivative Works of, publicly display, publicly perform,
+   sublicense, and distribute the Work and such Derivative Works in Source or
+   Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+   each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+   no-charge, royalty-free, irrevocable (except as stated in this section)
+   patent license to make, have made, use, offer to sell, sell, import, and
+   otherwise transfer the Work, where such license applies only to those patent
+   claims licensable by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s) with the
+   Work to which such Contribution(s) was submitted. If You institute patent
+   litigation against any entity (including a cross-claim or counterclaim in a
+   lawsuit) alleging that the Work or a Contribution incorporated within the
+   Work constitutes direct or contributory patent infringement, then any patent
+   licenses granted to You under this License for that Work shall terminate as
+   of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+   Derivative Works thereof in any medium, with or without modifications, and in
+   Source or Object form, provided that You meet the following conditions:
+
+   (a) You must give any other recipients of the Work or Derivative Works a copy
+   of this License; and
+
+   (b) You must cause any modified files to carry prominent notices stating that
+   You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works that You
+   distribute, all copyright, patent, trademark, and attribution notices from
+   the Source form of the Work, excluding those notices that do not pertain to
+   any part of the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its distribution,
+   then any Derivative Works that You distribute must include a readable copy of
+   the attribution notices contained within such NOTICE file, excluding those
+   notices that do not pertain to any part of the Derivative Works, in at least
+   one of the following places: within a NOTICE text file distributed as part of
+   the Derivative Works; within the Source form or documentation, if provided
+   along with the Derivative Works; or, within a display generated by the
+   Derivative Works, if and wherever such third-party notices normally appear.
+   The contents of the NOTICE file are for informational purposes only and do
+   not modify the License. You may add Your own attribution notices within
+   Derivative Works that You distribute, alongside or as an addendum to the
+   NOTICE text from the Work, provided that such additional attribution notices
+   cannot be construed as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and may
+   provide additional or different license terms and conditions for use,
+   reproduction, or distribution of Your modifications, or for any such
+   Derivative Works as a whole, provided Your use, reproduction, and
+   distribution of the Work otherwise complies with the conditions stated in
+   this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+   Contribution intentionally submitted for inclusion in the Work by You to the
+   Licensor shall be under the terms and conditions of this License, without any
+   additional terms or conditions. Notwithstanding the above, nothing herein
+   shall supersede or modify the terms of any separate license agreement you may
+   have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+   trademarks, service marks, or product names of the Licensor, except as
+   required for reasonable and customary use in describing the origin of the
+   Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+   writing, Licensor provides the Work (and each Contributor provides its
+   Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied, including, without limitation, any
+   warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+   FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining
+   the appropriateness of using or redistributing the Work and assume any risks
+   associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+   tort (including negligence), contract, or otherwise, unless required by
+   applicable law (such as deliberate and grossly negligent acts) or agreed to
+   in writing, shall any Contributor be liable to You for damages, including any
+   direct, indirect, special, incidental, or consequential damages of any
+   character arising as a result of this License or out of the use or inability
+   to use the Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all other
+   commercial damages or losses), even if such Contributor has been advised of
+   the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+   Derivative Works thereof, You may choose to offer, and charge a fee for,
+   acceptance of support, warranty, indemnity, or other liability obligations
+   and/or rights consistent with this License. However, in accepting such
+   obligations, You may act only on Your own behalf and on Your sole
+   responsibility, not on behalf of any other Contributor, and only if You agree
+   to indemnify, defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason of your
+   accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -1,3 +1,167 @@
-# Temporary Holding Version
+# @cyclone-ui/nextjs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Set up [Tamagui](https://tamagui.dev) and Cyclone UI components in a Next.js
+application. The package has two entry points:
+
+- `@cyclone-ui/nextjs`: `withCycloneUI`, a wrapper for `next.config.ts`
+- `@cyclone-ui/nextjs/provider`: `CycloneUIProvider`, the root client provider
+  with server-rendered light and dark themes
+
+They follow the [Tamagui Next.js guide](https://tamagui.dev/docs/guides/next-js),
+using `@tamagui/next-plugin` and `@tamagui/next-theme`.
+
+## Quick Features
+
+- Turbopack aliases for `react-native` → `react-native-web` and
+  `react-native-svg` → `@tamagui/react-native-svg`
+- The Tamagui compiler for Webpack builds through `@tamagui/next-plugin`
+- Builds the Tamagui config from your own design tokens (`tokens` option)
+- Defines `process.env.TAMAGUI_TARGET`, which Cyclone components read to render
+  web-only styles
+- Stores the light, dark or system setting and applies it before hydration
+- Collects react-native-web styles during server rendering
+
+## Installing
+
+Using [pnpm](http://pnpm.io):
+
+```bash
+pnpm add @cyclone-ui/nextjs @cyclone-ui/state @cyclone-ui/tokens @tamagui/core jotai react-native-web
+```
+
+Add `@tamagui/react-native-svg` if the app renders SVG icons, and
+`@tamagui/next-plugin` if it builds with Webpack.
+
+## Usage
+
+Wrap the Next.js config:
+
+```ts
+// next.config.ts
+import { withCycloneUI } from "@cyclone-ui/nextjs";
+
+export default withCycloneUI({
+  reactStrictMode: true
+});
+```
+
+Render the provider in the root layout. The provider sets a class on `<html>`
+before React hydrates, so add `suppressHydrationWarning` there:
+
+```tsx
+// app/layout.tsx
+import { CycloneUIProvider } from "@cyclone-ui/nextjs/provider";
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body>
+        <CycloneUIProvider>{children}</CycloneUIProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+Read or change the theme with `useThemeSetting`:
+
+```tsx
+"use client";
+
+import { useThemeSetting } from "@cyclone-ui/nextjs/provider";
+
+export function ThemeToggle() {
+  const theme = useThemeSetting();
+
+  return <button onClick={theme.toggle}>Theme: {theme.current}</button>;
+}
+```
+
+`useThemeMode` from `@cyclone-ui/state/theme` also returns the active mode.
+Change the theme through `useThemeSetting`: `useThemeActions` changes the
+Cyclone state only, so the choice isn't saved.
+
+### Custom design tokens
+
+Pass `tokens` to build the Tamagui config from your own design tokens instead
+of the Cyclone UI defaults. Use a DTCG token object, or token file paths or
+globs relative to the working directory:
+
+```ts
+// next.config.ts
+import { withCycloneUI } from "@cyclone-ui/nextjs";
+
+export default withCycloneUI(
+  { reactStrictMode: true },
+  {
+    tokens: [
+      "tokens/primitives.json",
+      "tokens/light.tokens.json",
+      "tokens/dark.tokens.json"
+    ]
+  }
+);
+```
+
+Files with a theme name (`light.tokens.json`, `dark.tokens.json`, …) become
+the `light` and `dark` themes. The tokens go through the same preprocessor and
+generator as `@cyclone-ui/tokens`, and a `razorwind.config.ts` in the project
+still applies (for example its fonts).
+
+With `tokens`, `withCycloneUI` returns a promise, which Next.js accepts as the
+config export. The config is written to `.cyclone-ui/tamagui.config.ts`
+(add `.cyclone-ui` to `.gitignore`) and replaces `@cyclone-ui/tokens/tamagui`
+everywhere, so `CycloneUIProvider` and the Webpack compiler use it. With
+pnpm, Webpack builds also need `@tamagui/web` and `motion` installed in the
+app, because the Tamagui compiler evaluates the generated config from the
+project root.
+
+### Provider props
+
+`CycloneUIProvider` accepts the
+[`NextThemeProvider` props](https://tamagui.dev/docs/guides/next-js#themes)
+(`defaultTheme`, `forcedTheme`, `storageKey`, `enableSystem`, and others), and:
+
+| Prop               | Default                                   | Description                                                                           |
+| ------------------ | ----------------------------------------- | ------------------------------------------------------------------------------------- |
+| `config`           | The config from `@cyclone-ui/tokens/tamagui` | The Tamagui config                                                                 |
+| `disableInjectCSS` | `false`                                   | Skip runtime theme CSS when the app imports CSS generated by the Tamagui compiler     |
+| `skipNextHead`     | `true`                                    | Render the theme script inline. Set `false` in the Pages Router to use `next/script` |
+
+### Webpack
+
+`next build --webpack` and `next dev --webpack` run the Tamagui compiler through
+`@tamagui/next-plugin`. Install it, then pass any
+[plugin options](https://tamagui.dev/docs/guides/next-js#older-versions-webpack)
+as the second argument:
+
+```ts
+export default withCycloneUI(nextConfig, {
+  outputCSS:
+    process.env.NODE_ENV === "production" ? "./public/tamagui.generated.css" : null,
+  disableExtraction: process.env.NODE_ENV === "development"
+});
+```
+
+The defaults are `config: "@cyclone-ui/tokens/tamagui"`,
+`components: ["@tamagui/core"]` and `appDir: true`. A `tamagui.build.ts` file
+in the project root overrides them.
+
+### Optimizing Turbopack builds
+
+Turbopack doesn't run the Tamagui compiler. To optimize production builds, run
+it with the Tamagui CLI (`@tamagui/cli`) before `next build`:
+
+```json
+{
+  "scripts": {
+    "build": "tamagui build --target web ./app -- next build"
+  }
+}
+```
+
+## Development
+
+```bash
+pnpm nx run nextjs:build
+```

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let e=require("node:module"),t=require("node:path");const n=(n,r,i)=>({...n,env:{TAMAGUI_TARGET:`web`,...n.env},turbopack:{...n.turbopack,resolveAlias:{"react-native":`react-native-web`,"react-native-svg":`@tamagui/react-native-svg`,...i&&{"@cyclone-ui/tokens/tamagui":`./${(0,t.relative)(process.cwd(),i)}`},...n.turbopack?.resolveAlias}},webpack:(a,o)=>{let{withTamagui:s}=(0,e.createRequire)((0,t.join)(o.dir,`package.json`))(`@tamagui/next-plugin`),c=s({config:i??`@cyclone-ui/tokens/tamagui`,components:[`@tamagui/core`],appDir:!0,...r})(n).webpack(a,o);return i&&(c.resolve.alias[`@cyclone-ui/tokens/tamagui$`]=i),c}});function r(e={},{tokens:t,...r}={}){return t?import(`@cyclone-ui/theme-builder`).then(async({buildTamaguiConfig:e})=>e({tokens:t})).then(t=>n(e,r,t)):n(e,r)}exports.withCycloneUI=r;

package/dist/index.d.cts

@@ -0,0 +1,67 @@
+import { BuildTamaguiConfigOptions } from "@cyclone-ui/theme-builder";
+import { WithTamaguiProps } from "@tamagui/next-plugin";
+import { NextConfig } from "next";
+/**
+ * The design tokens, plus options forwarded to `@tamagui/next-plugin` when
+ * Next.js builds with Webpack.
+ */
+type WithCycloneUIOptions = Partial<WithTamaguiProps> & {
+  /**
+   * Design tokens to build the app's Tamagui config from: a DTCG token
+   * object, or token file path(s) or globs relative to the working directory.
+   * Theme-named files (`light.tokens.json`, `dark.tokens.json`, …) become the
+   * `light` / `dark` themes.
+   *
+   * @remarks
+   * The config is generated into `.cyclone-ui/tamagui.config.ts` (add
+   * `.cyclone-ui` to `.gitignore`) when Next.js loads its config, and replaces
+   * `@cyclone-ui/tokens/tamagui` for the compiler and every import in the app,
+   * including `CycloneUIProvider`.
+   *
+   * @defaultValue The Cyclone UI config from `@cyclone-ui/tokens/tamagui`
+   */
+  tokens?: BuildTamaguiConfigOptions["tokens"];
+};
+/**
+ * Wrap a Next.js config with the setup Tamagui and Cyclone UI components need.
+ *
+ * @remarks
+ * - Turbopack (the Next.js default): aliases `react-native` to
+ *   `react-native-web` and `react-native-svg` to `@tamagui/react-native-svg`.
+ * - Webpack (`next build --webpack`): applies `@tamagui/next-plugin`, which
+ *   must be installed, with the Cyclone UI Tamagui config.
+ * - Both: defines `process.env.TAMAGUI_TARGET`.
+ *
+ * With `tokens`, the Tamagui config is built from them first, so this returns
+ * a promise, which Next.js accepts as the config export.
+ *
+ * Turbopack builds don't run the Tamagui compiler. To optimize them, use the
+ * Tamagui CLI: `tamagui build --target web ./src -- next build`.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withCycloneUI } from "@cyclone-ui/nextjs";
+ *
+ * export default withCycloneUI({ reactStrictMode: true });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // next.config.ts — build the Tamagui config from your own tokens
+ * import { withCycloneUI } from "@cyclone-ui/nextjs";
+ *
+ * export default withCycloneUI({}, { tokens: "tokens/**\/*.json" });
+ * ```
+ *
+ * @param nextConfig - The Next.js config to extend.
+ * @param options - The design `tokens`, plus options forwarded to
+ * `@tamagui/next-plugin` (Webpack only).
+ * @returns The extended Next.js config.
+ */
+declare function withCycloneUI(nextConfig?: NextConfig, options?: WithCycloneUIOptions & {
+  tokens?: undefined;
+}): NextConfig;
+declare function withCycloneUI(nextConfig: NextConfig | undefined, options: WithCycloneUIOptions): NextConfig | Promise<NextConfig>;
+export { WithCycloneUIOptions, withCycloneUI };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;KA4BY,uBAAuB,QAAQ;;;;;;;;;;;;;;;EAezC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkFK,cACd,aAAa,YACb,UAAU;EAAyB;IAClC;iBACa,cACd,YAAY,wBACZ,SAAS,uBACR,aAAa,QAAQ"}

package/dist/index.d.mts

@@ -0,0 +1,67 @@
+import { BuildTamaguiConfigOptions } from "@cyclone-ui/theme-builder";
+import { WithTamaguiProps } from "@tamagui/next-plugin";
+import { NextConfig } from "next";
+/**
+ * The design tokens, plus options forwarded to `@tamagui/next-plugin` when
+ * Next.js builds with Webpack.
+ */
+type WithCycloneUIOptions = Partial<WithTamaguiProps> & {
+  /**
+   * Design tokens to build the app's Tamagui config from: a DTCG token
+   * object, or token file path(s) or globs relative to the working directory.
+   * Theme-named files (`light.tokens.json`, `dark.tokens.json`, …) become the
+   * `light` / `dark` themes.
+   *
+   * @remarks
+   * The config is generated into `.cyclone-ui/tamagui.config.ts` (add
+   * `.cyclone-ui` to `.gitignore`) when Next.js loads its config, and replaces
+   * `@cyclone-ui/tokens/tamagui` for the compiler and every import in the app,
+   * including `CycloneUIProvider`.
+   *
+   * @defaultValue The Cyclone UI config from `@cyclone-ui/tokens/tamagui`
+   */
+  tokens?: BuildTamaguiConfigOptions["tokens"];
+};
+/**
+ * Wrap a Next.js config with the setup Tamagui and Cyclone UI components need.
+ *
+ * @remarks
+ * - Turbopack (the Next.js default): aliases `react-native` to
+ *   `react-native-web` and `react-native-svg` to `@tamagui/react-native-svg`.
+ * - Webpack (`next build --webpack`): applies `@tamagui/next-plugin`, which
+ *   must be installed, with the Cyclone UI Tamagui config.
+ * - Both: defines `process.env.TAMAGUI_TARGET`.
+ *
+ * With `tokens`, the Tamagui config is built from them first, so this returns
+ * a promise, which Next.js accepts as the config export.
+ *
+ * Turbopack builds don't run the Tamagui compiler. To optimize them, use the
+ * Tamagui CLI: `tamagui build --target web ./src -- next build`.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withCycloneUI } from "@cyclone-ui/nextjs";
+ *
+ * export default withCycloneUI({ reactStrictMode: true });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // next.config.ts — build the Tamagui config from your own tokens
+ * import { withCycloneUI } from "@cyclone-ui/nextjs";
+ *
+ * export default withCycloneUI({}, { tokens: "tokens/**\/*.json" });
+ * ```
+ *
+ * @param nextConfig - The Next.js config to extend.
+ * @param options - The design `tokens`, plus options forwarded to
+ * `@tamagui/next-plugin` (Webpack only).
+ * @returns The extended Next.js config.
+ */
+declare function withCycloneUI(nextConfig?: NextConfig, options?: WithCycloneUIOptions & {
+  tokens?: undefined;
+}): NextConfig;
+declare function withCycloneUI(nextConfig: NextConfig | undefined, options: WithCycloneUIOptions): NextConfig | Promise<NextConfig>;
+export { WithCycloneUIOptions, withCycloneUI };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":""}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{createRequire as e}from"node:module";import{join as t,relative as n}from"node:path";const r=(r,i,a)=>({...r,env:{TAMAGUI_TARGET:`web`,...r.env},turbopack:{...r.turbopack,resolveAlias:{"react-native":`react-native-web`,"react-native-svg":`@tamagui/react-native-svg`,...a&&{"@cyclone-ui/tokens/tamagui":`./${n(process.cwd(),a)}`},...r.turbopack?.resolveAlias}},webpack:(n,o)=>{let{withTamagui:s}=e(t(o.dir,`package.json`))(`@tamagui/next-plugin`),c=s({config:a??`@cyclone-ui/tokens/tamagui`,components:[`@tamagui/core`],appDir:!0,...i})(r).webpack(n,o);return a&&(c.resolve.alias[`@cyclone-ui/tokens/tamagui$`]=a),c}});function i(e={},{tokens:t,...n}={}){return t?import(`@cyclone-ui/theme-builder`).then(async({buildTamaguiConfig:e})=>e({tokens:t})).then(t=>r(e,n,t)):r(e,n)}export{i as withCycloneUI};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["extend","nextConfig","configPath","relative","createRequire","join","context","result","withTamagui","options","config","withCycloneUI","tokens","buildTamaguiConfig"],"sources":[],"mappings":""}

package/dist/provider.cjs

@@ -0,0 +1 @@
+"use client";Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let e=require("@cyclone-ui/state/theme"),t=require("@cyclone-ui/tokens/tamagui"),n=require("@tamagui/core"),r=require("@tamagui/next-theme"),i=require("next/navigation.js"),a=require("react"),o=require("react-native"),s=require("react/jsx-runtime");const c=[`light`,`dark`],l=({mode:t})=>{let{changeMode:n}=(0,e.useThemeActions)();return(0,a.useEffect)(()=>{n(t)},[n,t]),null};function u({children:a,config:u=t.config,disableInjectCSS:d=!1,skipNextHead:f=!0,onChangeTheme:p,...m}){let[h,g]=(0,r.useRootTheme)();return(0,i.useServerInsertedHTML)(()=>{let e=o.StyleSheet.getSheet();return/* @__PURE__ */ (0,s.jsx)(`style`,{id:e.id,dangerouslySetInnerHTML:{__html:e.textContent}})}),/* @__PURE__ */ (0,s.jsx)(r.NextThemeProvider,{...m,skipNextHead:f,onChangeTheme:e=>{g(e),p?.(e)},children:/* @__PURE__ */ (0,s.jsxs)(e.ThemeApi.Provider,{scope:`theme`,initialState:{mode:h,items:c},children:[/* @__PURE__ */ (0,s.jsx)(l,{mode:h}),/* @__PURE__ */ (0,s.jsx)(n.TamaguiProvider,{config:u,defaultTheme:h,disableInjectCSS:d,children:/* @__PURE__ */ (0,s.jsx)(n.Theme,{name:`${h}_base`,children:a})})]})})}exports.CycloneUIProvider=u,Object.defineProperty(exports,"useRootTheme",{enumerable:!0,get:function(){return r.useRootTheme}}),Object.defineProperty(exports,"useThemeSetting",{enumerable:!0,get:function(){return r.useThemeSetting}});

package/dist/provider.d.cts

@@ -0,0 +1,47 @@
+import { TamaguiProviderProps } from "@tamagui/core";
+import { ColorScheme, ThemeProviderProps, ThemeProviderProps as ThemeProviderProps$1, UseThemeProps, useRootTheme, useThemeSetting } from "@tamagui/next-theme";
+import { PropsWithChildren } from "react";
+type CycloneUIProviderProps = PropsWithChildren<Omit<ThemeProviderProps$1, "children"> & {
+  /**
+   * The Tamagui config.
+   *
+   * @defaultValue The Cyclone UI config from `@cyclone-ui/tokens/tamagui`
+   */
+  config?: TamaguiProviderProps["config"];
+  /**
+   * Skip injecting the Tamagui theme and token CSS at runtime. Set this when
+   * the app imports CSS generated by the Tamagui compiler (`outputCSS`).
+   *
+   * @defaultValue false
+   */
+  disableInjectCSS?: boolean;
+}>;
+/**
+ * The root provider for Cyclone UI components in a Next.js app.
+ *
+ * @remarks
+ * Renders `NextThemeProvider` from `@tamagui/next-theme`, which stores the
+ * light/dark/system setting and applies it before hydration, around a
+ * `TamaguiProvider` and the matching `<mode>_base` theme. It also collects
+ * react-native-web styles during server rendering. Read or change the theme
+ * with `useThemeSetting`.
+ *
+ * @example
+ * ```tsx
+ * // app/layout.tsx
+ * import { CycloneUIProvider } from "@cyclone-ui/nextjs/provider";
+ *
+ * export default function RootLayout({ children }: { children: React.ReactNode }) {
+ *   return (
+ *     <html lang="en" suppressHydrationWarning>
+ *       <body>
+ *         <CycloneUIProvider>{children}</CycloneUIProvider>
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ * ```
+ */
+declare function CycloneUIProvider({ children, config, disableInjectCSS, skipNextHead, onChangeTheme, ...props }: CycloneUIProviderProps): import("react").JSX.Element;
+export { type ColorScheme, CycloneUIProvider, CycloneUIProviderProps, type ThemeProviderProps, type UseThemeProps, useRootTheme, useThemeSetting };
+//# sourceMappingURL=provider.d.cts.map

package/dist/provider.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.cts","names":["ThemeProviderProps"],"sources":["../src/provider.tsx"],"mappings":";;;KAuCY,yBAAyB,kBACnC,KAAKA;;;;;;EAMH,SAAS;;;;;;;EAQT;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CY,oBACd,UACA,QACA,kBACA,cACA,kBACG,SACF,yCAAsB,IAAA"}

package/dist/provider.d.mts

@@ -0,0 +1,47 @@
+import { TamaguiProviderProps } from "@tamagui/core";
+import { ColorScheme, ThemeProviderProps, ThemeProviderProps as ThemeProviderProps$1, UseThemeProps, useRootTheme, useThemeSetting } from "@tamagui/next-theme";
+import { PropsWithChildren } from "react";
+type CycloneUIProviderProps = PropsWithChildren<Omit<ThemeProviderProps$1, "children"> & {
+  /**
+   * The Tamagui config.
+   *
+   * @defaultValue The Cyclone UI config from `@cyclone-ui/tokens/tamagui`
+   */
+  config?: TamaguiProviderProps["config"];
+  /**
+   * Skip injecting the Tamagui theme and token CSS at runtime. Set this when
+   * the app imports CSS generated by the Tamagui compiler (`outputCSS`).
+   *
+   * @defaultValue false
+   */
+  disableInjectCSS?: boolean;
+}>;
+/**
+ * The root provider for Cyclone UI components in a Next.js app.
+ *
+ * @remarks
+ * Renders `NextThemeProvider` from `@tamagui/next-theme`, which stores the
+ * light/dark/system setting and applies it before hydration, around a
+ * `TamaguiProvider` and the matching `<mode>_base` theme. It also collects
+ * react-native-web styles during server rendering. Read or change the theme
+ * with `useThemeSetting`.
+ *
+ * @example
+ * ```tsx
+ * // app/layout.tsx
+ * import { CycloneUIProvider } from "@cyclone-ui/nextjs/provider";
+ *
+ * export default function RootLayout({ children }: { children: React.ReactNode }) {
+ *   return (
+ *     <html lang="en" suppressHydrationWarning>
+ *       <body>
+ *         <CycloneUIProvider>{children}</CycloneUIProvider>
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ * ```
+ */
+declare function CycloneUIProvider({ children, config, disableInjectCSS, skipNextHead, onChangeTheme, ...props }: CycloneUIProviderProps): import("react").JSX.Element;
+export { type ColorScheme, CycloneUIProvider, CycloneUIProviderProps, type ThemeProviderProps, type UseThemeProps, useRootTheme, useThemeSetting };
+//# sourceMappingURL=provider.d.mts.map

package/dist/provider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.mts","names":["ThemeProviderProps"],"sources":["../src/provider.tsx"],"mappings":""}

package/dist/provider.mjs

@@ -0,0 +1,2 @@
+"use client";import{ThemeApi as e,useThemeActions as t}from"@cyclone-ui/state/theme";import{config as n}from"@cyclone-ui/tokens/tamagui";import{TamaguiProvider as r,Theme as i}from"@tamagui/core";import{NextThemeProvider as a,useRootTheme as o,useRootTheme as s,useThemeSetting as c}from"@tamagui/next-theme";import{useServerInsertedHTML as l}from"next/navigation.js";import{useEffect as u}from"react";import{StyleSheet as d}from"react-native";import{jsx as f,jsxs as p}from"react/jsx-runtime";const m=[`light`,`dark`],h=({mode:e})=>{let{changeMode:n}=t();return u(()=>{n(e)},[n,e]),null};function g({children:t,config:o=n,disableInjectCSS:c=!1,skipNextHead:u=!0,onChangeTheme:g,..._}){let[v,y]=s();return l(()=>{let e=d.getSheet();return/* @__PURE__ */ f(`style`,{id:e.id,dangerouslySetInnerHTML:{__html:e.textContent}})}),/* @__PURE__ */ f(a,{..._,skipNextHead:u,onChangeTheme:e=>{y(e),g?.(e)},children:/* @__PURE__ */ p(e.Provider,{scope:`theme`,initialState:{mode:v,items:m},children:[/* @__PURE__ */ f(h,{mode:v}),/* @__PURE__ */ f(r,{config:o,defaultTheme:v,disableInjectCSS:c,children:/* @__PURE__ */ f(i,{name:`${v}_base`,children:t})})]})})}export{g as CycloneUIProvider,o as useRootTheme,c as useThemeSetting};
+//# sourceMappingURL=provider.mjs.map

package/dist/provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.mjs","names":["cycloneConfig","useRootTheme","config","useRootTheme$1","ITEMS","SyncColorMode","useThemeActions","useEffect","changeMode","mode","CycloneUIProvider","config$1","config","props","setMode","useServerInsertedHTML","sheet","StyleSheet","NextThemeProvider","name","onChangeTheme","ThemeApi","TamaguiProvider","Theme","useRootTheme","useThemeSetting"],"sources":[],"mappings":""}

package/package.json

@@ -1,6 +1,81 @@
 {
   "name": "@cyclone-ui/nextjs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.3",
+  "type": "module",
+  "description": "A Next.js config wrapper and root provider that set up Tamagui and Cyclone UI components in Next.js applications.",
+  "repository": {
+    "type": "github",
+    "url": "https://github.com/storm-software/cyclone-ui.git",
+    "directory": "packages/nextjs"
+  },
+  "private": false,
+  "keywords": ["cyclone-ui", "tamagui", "nextjs", "next-plugin"],
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "default": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./package.json": "./package.json",
+    "./provider": {
+      "require": {
+        "types": "./dist/provider.d.cts",
+        "default": "./dist/provider.cjs"
+      },
+      "import": {
+        "types": "./dist/provider.d.mts",
+        "default": "./dist/provider.mjs"
+      },
+      "default": {
+        "types": "./dist/provider.d.mts",
+        "default": "./dist/provider.mjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "dependencies": {
+    "@cyclone-ui/theme-builder": "0.0.22",
+    "@tamagui/next-theme": "3.0.13"
+  },
+  "peerDependencies": {
+    "@cyclone-ui/state": "0.0.33",
+    "@cyclone-ui/tokens": "0.3.21",
+    "@tamagui/core": "3.0.13",
+    "@tamagui/next-plugin": "3.0.13",
+    "@tamagui/react-native-svg": "3.0.13",
+    "next": "^16.4.3",
+    "react": "^19.3.1",
+    "react-native": "^0.87.1",
+    "react-native-web": "0.19.12"
+  },
+  "peerDependenciesMeta": {
+    "@tamagui/next-plugin": { "optional": true },
+    "@tamagui/react-native-svg": { "optional": true },
+    "react-native": { "optional": true }
+  },
+  "devDependencies": {
+    "@cyclone-ui/state": "0.0.33",
+    "@cyclone-ui/tokens": "0.3.21",
+    "@powerlines/plugin-tsdown": "^0.1.618",
+    "@tamagui/core": "3.0.13",
+    "@tamagui/next-plugin": "3.0.13",
+    "@types/react": "^19.3.0",
+    "next": "^16.4.3",
+    "powerlines": "^0.47.217",
+    "react": "^19.3.1",
+    "react-native-web": "0.19.12"
+  },
+  "publishConfig": { "access": "public" },
+  "gitHead": "68d40b14f80f4c14e19d0491cdca0148fadfcf10"
+}