sp-reflex-components 0.2.0__tar.gz

sp_reflex_components-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,62 @@
+name: Release
+
+# Tag vX.Y.Z → test, build, publish to PyPI (trusted publishing / OIDC — no
+# API token secret), and attach the artifacts to a GitHub release.
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Test
+        run: |
+          uv sync
+          uv run pytest -q
+          uv run ruff check src tests
+          uv run ruff format --check .
+      - name: Build
+        run: |
+          uv build
+          sha256sum dist/* > SHA256SUMS && mv SHA256SUMS dist/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # PyPI trusted publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Remove non-distributable files
+        run: rm -f dist/SHA256SUMS
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create "${GITHUB_REF_NAME}" dist/* \
+            --repo "${GITHUB_REPOSITORY}" \
+            --title "${GITHUB_REF_NAME}" \
+            --notes "Published to PyPI as sp-reflex-components ${GITHUB_REF_NAME#v}. Wheel + sha256 also attached here."

sp_reflex_components-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+.pytest_cache/
+.ruff_cache/
+uv.lock

sp_reflex_components-0.2.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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.

sp_reflex_components-0.2.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: sp-reflex-components
+Version: 0.2.0
+Summary: Reflex component wrappers for AG Grid (community + enterprise modules) and React Flow - self-host on core Reflex without reflex-enterprise.
+Project-URL: Repository, https://github.com/MIM-SP/sp-reflex-components
+Project-URL: Issues, https://github.com/MIM-SP/sp-reflex-components/issues
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: ag-grid,components,react-flow,reflex
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.12
+Requires-Dist: reflex<0.10,>=0.9.5
+Description-Content-Type: text/markdown
+
+# sp-reflex-components
+
+Reflex component wrappers: **AG Grid** (ag-grid-react +
+community + enterprise modules) and **React Flow** (@xyflow/react). These
+replace `reflex-enterprise`'s component wrappers so apps self-host on core
+Reflex (Apache-2.0) with **no Reflex tier, token, badge, or reflex.dev
+dependency**.
+
+Built and maintained by Solid Power for internal Reflex apps; published in
+case others hit the same wall. Apache-2.0.
+
+## Install
+
+```bash
+uv add sp-reflex-components
+# or: pip install sp-reflex-components
+```
+
+## Use
+
+```python
+from sp_reflex_components import grid, flow
+
+# AG Grid — drop-in for reflex_enterprise's ag_grid.root(...)
+grid(
+    id="my-grid",
+    row_data=State.rows,
+    column_defs=[{"field": "name", "header_name": "Name", "editable": True}],
+    on_selection_changed=State.on_select,  # (rows, source, type)
+)
+
+# React Flow — drop-in for reflex_enterprise's flow(...)
+flow(
+    flow.controls(),
+    flow.background(variant="dots", gap=18, size=1),
+    nodes=State.nodes,
+    edges=State.edges,
+    fit_view=True,
+)
+```
+
+AG Grid Enterprise features (clipboard, cell selection) need
+`AG_GRID_LICENSE_KEY` in the environment **at compile time** — that is AG
+Grid's own per-developer license, unrelated to Reflex. Without it the grid
+runs in trial mode with a watermark.
+
+## Scope doctrine
+
+- A wrapper exposes **exactly** the prop/event surface consuming apps use —
+  no speculative props. Need a new prop? Add it here **with a test**, in the
+  same PR that uses it; every app inherits it.
+- npm versions are **pinned exactly** in this package. A bump is a deliberate
+  release with a changelog read (AG Grid majors change behavior: v35 added
+  no-matching-rows/exporting overlays, v36 overhauled the DOM containers).
+- Legacy CSS theming (`ag-theme-alpine` + `theme: "legacy"`) is deprecated
+  upstream; some future AG Grid major will force a Theming API migration —
+  that lands here once, for everyone.
+- Each consuming app should keep an adapter/wrapper **prop-equality test**
+  (both directions, derived from a real render) — see ATLAS's
+  `tests/unit/reflex_runtime/components/test_vendor_ag_grid.py` for the
+  pattern.
+
+## Known issues
+
+- React Flow renders nodes but **edge rendering has an unresolved defect**
+  (edges reach the ReactFlow component as props but no edge elements render;
+  reproduces identically under reflex-enterprise's own wrapper on
+  @xyflow/react 12.8.4 and 12.11.2, so it is not specific to this package).
+  Root cause TBD; issues/PRs welcome.
+
+## Dev
+
+```bash
+uv sync
+uv run pytest -q
+uv run ruff check src tests && uv run ruff format --check .
+```

sp_reflex_components-0.2.0/README.md

@@ -0,0 +1,77 @@
+# sp-reflex-components
+
+Reflex component wrappers: **AG Grid** (ag-grid-react +
+community + enterprise modules) and **React Flow** (@xyflow/react). These
+replace `reflex-enterprise`'s component wrappers so apps self-host on core
+Reflex (Apache-2.0) with **no Reflex tier, token, badge, or reflex.dev
+dependency**.
+
+Built and maintained by Solid Power for internal Reflex apps; published in
+case others hit the same wall. Apache-2.0.
+
+## Install
+
+```bash
+uv add sp-reflex-components
+# or: pip install sp-reflex-components
+```
+
+## Use
+
+```python
+from sp_reflex_components import grid, flow
+
+# AG Grid — drop-in for reflex_enterprise's ag_grid.root(...)
+grid(
+    id="my-grid",
+    row_data=State.rows,
+    column_defs=[{"field": "name", "header_name": "Name", "editable": True}],
+    on_selection_changed=State.on_select,  # (rows, source, type)
+)
+
+# React Flow — drop-in for reflex_enterprise's flow(...)
+flow(
+    flow.controls(),
+    flow.background(variant="dots", gap=18, size=1),
+    nodes=State.nodes,
+    edges=State.edges,
+    fit_view=True,
+)
+```
+
+AG Grid Enterprise features (clipboard, cell selection) need
+`AG_GRID_LICENSE_KEY` in the environment **at compile time** — that is AG
+Grid's own per-developer license, unrelated to Reflex. Without it the grid
+runs in trial mode with a watermark.
+
+## Scope doctrine
+
+- A wrapper exposes **exactly** the prop/event surface consuming apps use —
+  no speculative props. Need a new prop? Add it here **with a test**, in the
+  same PR that uses it; every app inherits it.
+- npm versions are **pinned exactly** in this package. A bump is a deliberate
+  release with a changelog read (AG Grid majors change behavior: v35 added
+  no-matching-rows/exporting overlays, v36 overhauled the DOM containers).
+- Legacy CSS theming (`ag-theme-alpine` + `theme: "legacy"`) is deprecated
+  upstream; some future AG Grid major will force a Theming API migration —
+  that lands here once, for everyone.
+- Each consuming app should keep an adapter/wrapper **prop-equality test**
+  (both directions, derived from a real render) — see ATLAS's
+  `tests/unit/reflex_runtime/components/test_vendor_ag_grid.py` for the
+  pattern.
+
+## Known issues
+
+- React Flow renders nodes but **edge rendering has an unresolved defect**
+  (edges reach the ReactFlow component as props but no edge elements render;
+  reproduces identically under reflex-enterprise's own wrapper on
+  @xyflow/react 12.8.4 and 12.11.2, so it is not specific to this package).
+  Root cause TBD; issues/PRs welcome.
+
+## Dev
+
+```bash
+uv sync
+uv run pytest -q
+uv run ruff check src tests && uv run ruff format --check .
+```

sp_reflex_components-0.2.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "sp-reflex-components"
+version = "0.2.0"
+description = "Reflex component wrappers for AG Grid (community + enterprise modules) and React Flow - self-host on core Reflex without reflex-enterprise."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+keywords = ["reflex", "ag-grid", "react-flow", "components"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: User Interfaces",
+]
+dependencies = [
+    "reflex>=0.9.5,<0.10",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.8",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sp_reflex_components"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.urls]
+Repository = "https://github.com/MIM-SP/sp-reflex-components"
+Issues = "https://github.com/MIM-SP/sp-reflex-components/issues"

sp_reflex_components-0.2.0/src/sp_reflex_components/__init__.py

@@ -0,0 +1,48 @@
+"""Solid Power shared Reflex component wrappers.
+
+Own wrappers over the same npm packages reflex-enterprise wrapped — AG Grid
+(ag-grid-react + community + enterprise modules) and React Flow
+(@xyflow/react) — with no Reflex tier, token, or badge requirements.
+
+Scope doctrine (from ATLAS SPEC §V64): a wrapper exposes exactly the prop and
+event surface consuming apps actually use. Need a new prop? Add it HERE with a
+test, in the same PR that uses it — every consuming app then inherits it.
+Never add speculative props. npm versions are pinned exactly in this package;
+a bump is a deliberate, changelog-reviewed release.
+
+AG Grid Enterprise features are licensed by AG Grid's own per-developer
+license (``AG_GRID_LICENSE_KEY`` env var at compile time in each app) —
+entirely unrelated to Reflex.
+"""
+
+from sp_reflex_components.ag_grid import (
+    AG_GRID_LICENSE_KEY_ENV,
+    AG_GRID_VERSION,
+    AgGrid,
+    grid,
+)
+from sp_reflex_components.react_flow import (
+    XYFLOW_VERSION,
+    Background,
+    Controls,
+    Edge,
+    Flow,
+    Node,
+    XYPosition,
+    flow,
+)
+
+__all__ = [
+    "AG_GRID_LICENSE_KEY_ENV",
+    "AG_GRID_VERSION",
+    "XYFLOW_VERSION",
+    "AgGrid",
+    "Background",
+    "Controls",
+    "Edge",
+    "Flow",
+    "Node",
+    "XYPosition",
+    "flow",
+    "grid",
+]

sp_reflex_components-0.2.0/src/sp_reflex_components/ag_grid.py

@@ -0,0 +1,231 @@
+"""AG Grid wrapper over ag-grid-react — no reflex-enterprise required.
+
+Wraps the same npm packages reflex-enterprise wrapped, scoped to the surface
+consuming apps actually use (see package scope doctrine in ``__init__``).
+AG Grid Enterprise features are licensed by AG_GRID_LICENSE_KEY (AG Grid's
+own per-developer product license, independent of Reflex).
+
+v34 theming: the app uses legacy CSS themes (`ag-theme-alpine` class), so the
+grid opts back into legacy mode globally via `provideGlobalGridOptions`.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, ClassVar, TypedDict
+
+import reflex as rx
+from reflex.vars.base import Var
+from reflex.vars.object import ObjectVar
+
+# Exact pin; bump = deliberate release w/ changelog read (scope doctrine).
+# 36.1.0 chosen 2026-08-07 (v35/v36 upgrade guides: no removals in our surface;
+# legacy theming still supported-but-deprecated — next major may remove it).
+AG_GRID_VERSION = "36.1.0"
+_REACT_PKG = f"ag-grid-react@{AG_GRID_VERSION}"
+_COMMUNITY_PKG = "ag-grid-community"
+_ENTERPRISE_PKG = "ag-grid-enterprise"
+
+AG_GRID_LICENSE_KEY_ENV = "AG_GRID_LICENSE_KEY"
+
+# Adapter passes theme="alpine" only (§V64 scope); unknown values fall back.
+_THEME_CLASSES = {"alpine": "ag-theme-alpine"}
+_DEFAULT_THEME = "alpine"
+
+
+class CellEventSpec(TypedDict):
+    """Payload for cell click events (shape consumed by existing states)."""
+
+    type: str
+    data: dict
+    value: Any
+    colDef: dict
+    rowIndex: int
+    rowPinned: str | None
+
+
+class RowEventSpec(TypedDict):
+    """Payload for row events (shape consumed by existing states)."""
+
+    type: str
+    data: dict
+    rowIndex: int
+    rowPinned: str | None
+
+
+class CellValueChangedEventSpec(TypedDict):
+    """Payload for cell value edits (shape consumed by existing states)."""
+
+    rowIndex: int
+    field: str
+    newValue: Any
+    node_id: str
+
+
+def _on_selection_changed_spec(
+    event: ObjectVar[dict],
+) -> tuple[Var[list[dict]], Var[str], Var[str]]:
+    return (
+        Var(f"{event}.api.getSelectedRows()").to(list[dict]),
+        event.source.to(str),
+        event.type.to(str),
+    )
+
+
+def _on_cell_value_changed_spec(
+    event: ObjectVar[dict],
+) -> tuple[Var[CellValueChangedEventSpec]]:
+    return (
+        Var.create(
+            {
+                "rowIndex": event.rowIndex,
+                # Nested attribute access on an untyped ObjectVar raises
+                # UntypedVarError at compile — use explicit JS expressions.
+                "field": Var(f"{event}.colDef.field").to(str),
+                "newValue": event.newValue,
+                "node_id": Var(f"{event}.node.id").to(str),
+            }
+        ).to(CellValueChangedEventSpec),
+    )
+
+
+def _on_cell_event_spec(event: ObjectVar[dict]) -> tuple[Var[CellEventSpec]]:
+    return (
+        Var.create(
+            {
+                "type": event.type,
+                "data": event.data,
+                "value": event.value,
+                "colDef": event.colDef,
+                "rowIndex": event.rowIndex,
+                "rowPinned": event.rowPinned,
+            }
+        ).to(CellEventSpec),
+    )
+
+
+def _on_row_event_spec(event: ObjectVar[dict]) -> tuple[Var[RowEventSpec]]:
+    return (
+        Var.create(
+            {
+                "type": event.type,
+                "data": event.data,
+                "rowIndex": event.rowIndex,
+                "rowPinned": event.rowPinned,
+            }
+        ).to(RowEventSpec),
+    )
+
+
+class AgGrid(rx.NoSSRComponent):
+    """AgGridReact scoped to the consuming apps' adapter surface."""
+
+    library = _REACT_PKG
+    tag = "AgGridReact"
+
+    # Reflex's component idiom uses a class-attr list here (same upstream).
+    lib_dependencies: list[str] = [  # noqa: RUF012
+        f"{_COMMUNITY_PKG}@{AG_GRID_VERSION}",
+        f"{_ENTERPRISE_PKG}@{AG_GRID_VERSION}",
+    ]
+
+    # AG Grid's own DOM id prop is gridId; `id` collides with the React DOM prop.
+    _rename_props: ClassVar[dict[str, str]] = {"id": "gridId"}
+
+    # --- props (adapter surface, data_grid.py grid_props) ---
+    row_data: Var[list[dict]]
+    column_defs: Var[list[dict]]
+    default_col_def: Var[dict]
+    animate_rows: Var[bool]
+    header_height: Var[int]
+    row_height: Var[int]
+    ensure_dom_order: Var[bool]
+    enable_cell_text_selection: Var[bool]
+    overlay_no_rows_template: Var[str]
+    pagination: Var[bool]
+    suppress_csv_export: Var[bool]
+    cell_selection: Var[bool]
+    suppress_clipboard_paste: Var[bool]
+    single_click_edit: Var[bool]
+    # Correct AG Grid option name (the enterprise wrapper emitted the invalid
+    # `stopEditWhenCellLosesFocus`, which AG Grid rejects).
+    stop_editing_when_cells_lose_focus: Var[bool]
+    dom_layout: Var[str]
+    quick_filter_text: Var[str]
+    # v35 added noMatchingRows/exporting overlays; adapter suppresses them for
+    # v34-parity (custom no-rows overlay remains the only overlay — §V66).
+    suppress_overlays: Var[list[str]]
+    get_row_id: Var[Any]
+    row_selection: Var[dict]
+
+    # --- events (adapter surface) ---
+    on_selection_changed: rx.EventHandler[_on_selection_changed_spec]
+    on_cell_value_changed: rx.EventHandler[_on_cell_value_changed_spec]
+    on_cell_clicked: rx.EventHandler[_on_cell_event_spec]
+    on_row_double_clicked: rx.EventHandler[_on_row_event_spec]
+
+    def add_imports(self) -> dict[str, list[str]]:
+        """Modules, license manager, and legacy theme CSS."""
+        return {
+            "": [
+                f"{_COMMUNITY_PKG}/styles/ag-grid.css",
+                f"{_COMMUNITY_PKG}/styles/ag-theme-alpine.css",
+            ],
+            _COMMUNITY_PKG: [
+                "ModuleRegistry",
+                "AllCommunityModule",
+                "provideGlobalGridOptions",
+            ],
+            _ENTERPRISE_PKG: [
+                "ClipboardModule",
+                "CellSelectionModule",
+                "LicenseManager",
+            ],
+        }
+
+    def add_custom_code(self) -> list[str]:
+        """License key + module registration + legacy theming."""
+        license_key = os.getenv(AG_GRID_LICENSE_KEY_ENV)
+        license_arg = f"'{license_key}'" if license_key else "null"
+        return [
+            f"LicenseManager.setLicenseKey({license_arg});",
+            (
+                "ModuleRegistry.registerModules("
+                "[AllCommunityModule, ClipboardModule, CellSelectionModule]);"
+            ),
+            'provideGlobalGridOptions({"theme": "legacy"});',
+        ]
+
+
+def _camelize_keys(value: Any) -> Any:
+    """Recursively camelize dict keys in plain-Python grid option structures.
+
+    AG Grid ignores snake_case option names (headerName, cellDataType, …), and
+    the adapter builds column defs with snake_case keys. Vars and non-container
+    values (e.g. FunctionStringVar formatters) pass through untouched.
+    """
+    from reflex.utils.format import to_camel_case
+
+    if isinstance(value, dict):
+        return {to_camel_case(key): _camelize_keys(val) for key, val in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_camelize_keys(item) for item in value]
+    return value
+
+
+def grid(*, theme: str = _DEFAULT_THEME, **props: Any) -> rx.Component:
+    """AG Grid inside a legacy-theme container filling its parent.
+
+    Drop-in replacement for reflex-enterprise's `ag_grid.root`. Nested
+    column_defs/default_col_def keys are camelized here (adapter-scoped
+    normalization — AgGrid itself stays a pure passthrough).
+    """
+    for key in ("column_defs", "default_col_def"):
+        if key in props and not isinstance(props[key], Var):
+            props[key] = _camelize_keys(props[key])
+    theme_class = _THEME_CLASSES.get(theme, _THEME_CLASSES[_DEFAULT_THEME])
+    return rx.el.div(
+        AgGrid.create(**props),
+        class_name=theme_class,
+        style={"height": "100%", "width": "100%"},
+    )

sp_reflex_components-0.2.0/src/sp_reflex_components/react_flow.py

@@ -0,0 +1,95 @@
+"""React Flow wrapper over @xyflow/react — no reflex-enterprise required.
+
+Scoped to the surface consuming apps use: the ReactFlow canvas with static
+(controlled) nodes/edges, Controls, and a Background pattern.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+import reflex as rx
+from reflex.vars.base import Var
+
+# Exact pin; bump = deliberate release. 12.11.2 = latest 12.x (2026-08-07),
+# same major reflex-enterprise wrapped (@xyflow/react@12.8.4).
+XYFLOW_VERSION = "12.11.2"
+_LIBRARY = f"@xyflow/react@{XYFLOW_VERSION}"
+
+
+class XYPosition(TypedDict):
+    """Canvas coordinates."""
+
+    x: float
+    y: float
+
+
+class Node(TypedDict, total=False):
+    """React Flow node — fields our layout payload emits."""
+
+    id: str
+    position: XYPosition
+    data: dict
+    style: dict
+
+
+class Edge(TypedDict, total=False):
+    """React Flow edge — fields our layout payload emits."""
+
+    id: str
+    source: str
+    target: str
+    label: str
+    type: str
+
+
+class _FlowBase(rx.NoSSRComponent):
+    library = _LIBRARY
+
+    def add_imports(self) -> dict[str, list[str]]:
+        return {"": ["@xyflow/react/dist/style.css"]}
+
+
+class Flow(_FlowBase):
+    """ReactFlow canvas scoped to the consuming apps' adapter surface."""
+
+    tag = "ReactFlow"
+    is_default = False
+
+    nodes: Var[list[Node]]
+    edges: Var[list[Edge]]
+    fit_view: Var[bool]
+    nodes_draggable: Var[bool]
+    nodes_connectable: Var[bool]
+    edges_reconnectable: Var[bool]
+
+
+class Controls(_FlowBase):
+    """Zoom/fit controls."""
+
+    tag = "Controls"
+    is_default = False
+
+
+class Background(_FlowBase):
+    """Canvas background pattern."""
+
+    tag = "Background"
+    is_default = False
+
+    variant: Var[str]
+    gap: Var[int]
+    size: Var[int]
+
+
+class _FlowNamespace:
+    """Callable namespace mirroring the adapter's `flow(...)` usage."""
+
+    controls = Controls.create
+    background = Background.create
+
+    def __call__(self, *children: Any, **props: Any) -> rx.Component:
+        return Flow.create(*children, **props)
+
+
+flow = _FlowNamespace()

sp_reflex_components-0.2.0/tests/test_wrappers.py

@@ -0,0 +1,103 @@
+"""Standalone contract tests for the shared wrappers.
+
+App-specific adapter/wrapper prop-surface EQUALITY tests live in each
+consuming app (they need that app's adapter); these cover everything the
+package can prove on its own.
+"""
+
+from __future__ import annotations
+
+import sp_reflex_components as spc
+
+
+def test_ag_grid_pins_exact_and_consistent() -> None:
+    version = spc.AG_GRID_VERSION
+    assert version.count(".") == 2 and all(p.isdigit() for p in version.split("."))
+    assert spc.AgGrid.library == f"ag-grid-react@{version}"
+    assert set(spc.AgGrid().lib_dependencies) == {
+        f"ag-grid-community@{version}",
+        f"ag-grid-enterprise@{version}",
+    }
+
+
+def test_ag_grid_modules_license_and_css() -> None:
+    component = spc.AgGrid.create()
+
+    code = "\n".join(component.add_custom_code())
+    assert "LicenseManager.setLicenseKey(" in code
+    assert "ModuleRegistry.registerModules(" in code
+    for module in ("AllCommunityModule", "ClipboardModule", "CellSelectionModule"):
+        assert module in code
+    assert '"theme": "legacy"' in code
+
+    imports = component.add_imports()
+    assert "ag-grid-community/styles/ag-grid.css" in imports[""]
+    assert "ag-grid-community/styles/ag-theme-alpine.css" in imports[""]
+    assert "LicenseManager" in imports["ag-grid-enterprise"]
+
+
+def test_ag_grid_license_key_from_env(monkeypatch) -> None:
+    monkeypatch.setenv(spc.AG_GRID_LICENSE_KEY_ENV, "test-key-123")
+    assert "LicenseManager.setLicenseKey('test-key-123');" in spc.AgGrid.create().add_custom_code()
+
+    monkeypatch.delenv(spc.AG_GRID_LICENSE_KEY_ENV)
+    assert "LicenseManager.setLicenseKey(null);" in spc.AgGrid.create().add_custom_code()
+
+
+def test_ag_grid_emits_correct_stop_editing_prop() -> None:
+    rendered = str(spc.AgGrid.create(stop_editing_when_cells_lose_focus=True).render())
+    assert "stopEditingWhenCellsLoseFocus" in rendered
+    assert "stopEditWhenCellLosesFocus" not in rendered
+
+
+def test_grid_helper_camelizes_nested_option_keys() -> None:
+    rendered = str(
+        spc.grid(
+            row_data=[],
+            column_defs=[
+                {
+                    "field": "name",
+                    "header_name": "Name",
+                    "cell_data_type": "text",
+                    "cell_editor_params": {"values": ["a", "b"]},
+                }
+            ],
+            default_col_def={"min_width": 72, "suppress_header_menu_button": True},
+        ).render()
+    )
+    for camel in (
+        "headerName",
+        "cellDataType",
+        "cellEditorParams",
+        "minWidth",
+        "suppressHeaderMenuButton",
+    ):
+        assert camel in rendered, f"missing camelized key {camel}"
+    for snake in ("header_name", "cell_data_type", "min_width"):
+        assert snake not in rendered, f"unconverted key {snake} leaked through"
+    assert "ag-theme-alpine" in rendered
+
+
+def test_react_flow_pin_and_style_css() -> None:
+    version = spc.XYFLOW_VERSION
+    assert version.count(".") == 2 and all(p.isdigit() for p in version.split("."))
+    assert spc.Flow.library == f"@xyflow/react@{version}"
+    assert "@xyflow/react/dist/style.css" in spc.Flow.create().add_imports()[""]
+
+
+def test_flow_namespace_matches_enterprise_call_shape() -> None:
+    component = spc.flow(
+        spc.flow.controls(),
+        spc.flow.background(variant="dots", gap=18, size=1),
+        id="canvas",
+        nodes=[],
+        edges=[],
+        fit_view=True,
+        nodes_draggable=False,
+        nodes_connectable=False,
+        edges_reconnectable=False,
+    )
+    rendered = str(component.render())
+    assert "ReactFlow" in rendered
+    assert "Controls" in rendered
+    assert "Background" in rendered