@asheeui/puck 0.0.0-stage → 2.3.1

package/LICENSE

@@ -0,0 +1,201 @@
+                              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 2026 Ashee Softworks
+
+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/NOTICE

@@ -0,0 +1,10 @@
+AsheeUI
+Copyright 2026 Ashee Softworks
+
+This product includes software developed at Ashee Softworks
+(https://github.com/AsheeSoftworks/AsheeUI).
+
+The framework's design system, component contracts and development
+methodology are documented in this repository. The AI Test Driven
+Development methodology that the project is developed with is created by
+Ashee Softworks.

package/README.md

@@ -1,3 +1,126 @@
-# Temporary Holding Version
-
-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.
+# @asheeui/puck
+
+The AsheeUI [Puck](https://puckeditor.com) integration: one block registry behind one
+import, usable by a web application and by a React Native one.
+
+A page composed in a visual builder has to mean the same thing on a browser and on a
+device. This package is arranged so that it does: the block **specs** — the label a
+builder shows, the fields it fills in, the value each block starts as — live once, and
+each platform supplies only the drawing.
+
+```bash
+npm install @asheeui/puck @puckeditor/core
+```
+
+`@puckeditor/core` is an optional peer. It is needed by the web half alone; the native
+half loads without it.
+
+## What each platform gets
+
+| Platform | The package is | You write |
+| --- | --- | --- |
+| Web | the editor's block registry (`asheePuckConfig`) and the editor's page renderer | `<Puck config={asheePuckConfig} … />` to compose, `<PuckPage data={page} />` to show |
+| React Native | the same specs, plus a renderer that draws a stored page with the native components | `<PuckPage data={page} />` |
+
+There is no editor on native, and none is planned: a device **shows** a page. What
+composes one is the web editor, which is where authoring happens.
+
+## Usage
+
+The editor, on the web:
+
+```tsx
+import { Puck } from "@puckeditor/core";
+import { asheePuckConfig } from "@asheeui/puck";
+import "@puckeditor/core/puck.css";
+import "@asheeui/web/styles";
+
+export function Editor() {
+  return <Puck config={asheePuckConfig} data={savedPage} onPublish={save} />;
+}
+```
+
+A published page, on either platform — the same import, the same call:
+
+```tsx
+import { PuckPage } from "@asheeui/puck";
+
+export function PublishedPage({ page }) {
+  return <PuckPage data={page} />;
+}
+```
+
+Blocks resolve their theme through the framework provider. The page shell supplies one
+when the application has not, and respects the one it already has, so a `defaultTheme`
+or a component override in your own provider keeps applying to a built page.
+
+## Blocks
+
+| Category | Blocks |
+| --- | --- |
+| Layout | `Section`, `Columns` |
+| Navigation | `Navbar`, `Footer` |
+| Hero | `Hero` |
+| Content | `Heading`, `Text` |
+| Features | `FeatureGrid` |
+| CTA | `CTA` |
+| Pricing | `PricingCard` |
+| Testimonials | `Testimonials` |
+| Utility | `EmptyState` |
+
+There are no `PuckHero`, `PuckNavbar` or `PuckFooter` components. Each block is the
+framework component plus the configuration a builder can own, so a block cannot drift
+away from the component an application renders — and a block added once is offered by
+both platforms.
+
+## The configuration boundary
+
+A block exposes its **visual configuration**, not its React API. The boundary is the
+same for every block:
+
+| In the configuration | Out of the configuration |
+| --- | --- |
+| Wording, alignment, spacing, background, columns | Icons and arbitrary React nodes |
+| Destinations and action wording | Click handlers and functions |
+| Repeatable content (features, quotes, links) | Data from an application, a database or a request |
+
+Everything inside the configuration survives a JSON round trip, which is what a saved
+page is. A block that needed a runtime value would be a component problem rather than a
+builder problem.
+
+## Layout
+
+```text
+src/
+  shared/   the specs, the field builders and the adapters — no renderer, no editor
+  web/      the editor's registry, its page renderer and the DOM drawings
+  native/   the native registry, the stored-page renderer and the platform drawings
+  index.ts          the web entry   (`@asheeui/puck`)
+  index.native.ts   the native entry (Metro's `react-native` field)
+```
+
+The split is the reason the package can be used on both platforms: a browser bundle
+reaches `web/` alone, and a device bundle reaches `native/` without loading React DOM,
+Tailwind or the editor.
+
+## Adding a block
+
+A block is one entry in `src/shared/blocks` plus one drawing per platform. State the
+specs — the label, the fields and the default value — and then render the component on
+each platform, reading the props the spec describes. A test in the same change asserts
+what `src/shared/spec.test.ts` asserts for every block: that the block is labelled, that
+its fields are types a builder understands, that it is filed under a category, and that
+its defaults survive a JSON round trip.
+
+## Requirements
+
+- React 18 or 19.
+- `@puckeditor/core` `^0.23.0` for the web half.
+- `react-native` and `nativewind` for the native half, configured the way
+  [the native package](https://github.com/AsheeSoftworks/AsheeUI/blob/main/docs/native.md)
+  documents. Add `@asheeui/puck` to the Tailwind content globs as well, so the classes
+  the native drawings name are compiled.
+
+---
+
+Built with AI. See [Ashee Softworks](https://asheesoftworks.com).

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The AsheeUI Puck integration.
+ *
+ * One import, two renderers. An application installs `@asheeui/puck` and writes the same
+ * specifiers whether it runs in a browser or on a device; the resolver decides which half
+ * answers:
+ *
+ * - On the web, it reads `main` (and the `import` condition) and reaches this file,
+ *   which is the editor's block registry, the editor's page renderer and the shared
+ *   specs behind them.
+ * - Under Expo and Metro, it reads the manifest's `react-native` field, then the
+ *   `react-native` condition of the exports map, and finally Metro's platform extension
+ *   (`.native.ts` beside `.ts`), and reaches `./index.native`, which renders a stored
+ *   page with the native components.
+ *
+ * The routing is a property of the file name and the manifest rather than of a runtime
+ * check, which is what keeps a browser bundle free of React Native and a device bundle
+ * free of the DOM edition of the framework. This module is the web branch, and it
+ * imports no native renderer.
+ */
+export * from "./web";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use client";
+/**
+ * The AsheeUI Puck integration.
+ *
+ * One import, two renderers. An application installs `@asheeui/puck` and writes the same
+ * specifiers whether it runs in a browser or on a device; the resolver decides which half
+ * answers:
+ *
+ * - On the web, it reads `main` (and the `import` condition) and reaches this file,
+ *   which is the editor's block registry, the editor's page renderer and the shared
+ *   specs behind them.
+ * - Under Expo and Metro, it reads the manifest's `react-native` field, then the
+ *   `react-native` condition of the exports map, and finally Metro's platform extension
+ *   (`.native.ts` beside `.ts`), and reaches `./index.native`, which renders a stored
+ *   page with the native components.
+ *
+ * The routing is a property of the file name and the manifest rather than of a runtime
+ * check, which is what keeps a browser bundle free of React Native and a device bundle
+ * free of the DOM edition of the framework. This module is the web branch, and it
+ * imports no native renderer.
+ */
+export * from "./web";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,OAAO,CAAC"}

package/dist/index.native.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The AsheeUI Puck integration, native branch.
+ *
+ * Metro reaches this file for a React Native platform — through the manifest's
+ * `react-native` field, through the `react-native` condition of the exports map, or by
+ * resolving the platform extension (`.native`) beside `index.ts` — so an application's
+ * import specifiers do not change between the web and a device.
+ *
+ * It exports the native registry and the native page renderer alongside the same shared
+ * specs the web branch exports, because the point of the package is that the import a
+ * developer writes is the same one on both platforms. It imports no DOM renderer and
+ * nothing from the editor: resolving this file must not pull Tailwind, React DOM or
+ * `@puckeditor/core` into a native bundle.
+ *
+ * The file is published as source rather than only as a build, and so are the modules it
+ * imports, because the manifest's `react-native` field cannot be redirected at publish
+ * time the way `main` and `types` are: whatever that field names has to exist in the
+ * tarball, and a resolver that reads the field instead of the exports map has to be able
+ * to compile it and everything it reaches.
+ */
+export * from "./native";
+//# sourceMappingURL=index.native.d.ts.map

package/dist/index.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.native.d.ts","sourceRoot":"","sources":["../src/index.native.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,UAAU,CAAC"}

package/dist/index.native.js

@@ -0,0 +1,22 @@
+/**
+ * The AsheeUI Puck integration, native branch.
+ *
+ * Metro reaches this file for a React Native platform — through the manifest's
+ * `react-native` field, through the `react-native` condition of the exports map, or by
+ * resolving the platform extension (`.native`) beside `index.ts` — so an application's
+ * import specifiers do not change between the web and a device.
+ *
+ * It exports the native registry and the native page renderer alongside the same shared
+ * specs the web branch exports, because the point of the package is that the import a
+ * developer writes is the same one on both platforms. It imports no DOM renderer and
+ * nothing from the editor: resolving this file must not pull Tailwind, React DOM or
+ * `@puckeditor/core` into a native bundle.
+ *
+ * The file is published as source rather than only as a build, and so are the modules it
+ * imports, because the manifest's `react-native` field cannot be redirected at publish
+ * time the way `main` and `types` are: whatever that field names has to exist in the
+ * tarball, and a resolver that reads the field instead of the exports map has to be able
+ * to compile it and everything it reaches.
+ */
+export * from "./native";
+//# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.native.js","sourceRoot":"","sources":["../src/index.native.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,UAAU,CAAC"}

package/dist/native/blocks/content.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The platform content blocks.
+ *
+ * Each block is the framework component plus the shared spec: the label, the fields and
+ * the defaults come from `src/shared`, and only the drawing is written here. What the
+ * platform draws differently is stated in the block: a paragraph's alignment is a
+ * property of its `Typography` rather than a class on a paragraph element, so the shared
+ * alignment vocabulary is what reaches the component.
+ */
+import type { AsheeBlock, HeadingBlockProps, TextBlockProps } from "../../shared";
+/**
+ * A section heading with an optional eyebrow and description.
+ */
+export declare const headingBlock: AsheeBlock<HeadingBlockProps>;
+/**
+ * A paragraph of body text.
+ */
+export declare const textBlock: AsheeBlock<TextBlockProps>;
+//# sourceMappingURL=content.d.ts.map

package/dist/native/blocks/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/native/blocks/content.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACf,MAAM,cAAc,CAAC;AAGtB;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,iBAAiB,CAetD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,UAAU,CAAC,cAAc,CAahD,CAAC"}

package/dist/native/blocks/content.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The platform content blocks.
+ *
+ * Each block is the framework component plus the shared spec: the label, the fields and
+ * the defaults come from `src/shared`, and only the drawing is written here. What the
+ * platform draws differently is stated in the block: a paragraph's alignment is a
+ * property of its `Typography` rather than a class on a paragraph element, so the shared
+ * alignment vocabulary is what reaches the component.
+ */
+import { Container, SECTION_BLOCK_TEXT_ALIGN, Section, Typography, } from "@asheeui/native";
+import { SectionHeading } from "@asheeui/native/section-kit";
+import { HEADING_SPEC, TEXT_SPEC } from "../../shared";
+/**
+ * A section heading with an optional eyebrow and description.
+ */
+export const headingBlock = {
+    ...HEADING_SPEC,
+    render: ({ eyebrow, title, description, align }) => (_jsx(Section, { spacing: "md", children: _jsx(Container, { children: _jsx(SectionHeading, { eyebrow: eyebrow || undefined, title: title || undefined, description: description || undefined, align: align ?? "start", size: "lg" }) }) })),
+};
+/**
+ * A paragraph of body text.
+ */
+export const textBlock = {
+    ...TEXT_SPEC,
+    render: ({ text, align }) => (_jsx(Section, { spacing: "sm", children: _jsx(Container, { children: _jsx(Typography, { role: "body-lg", align: SECTION_BLOCK_TEXT_ALIGN[align ?? "start"], children: text }) }) })),
+};
+//# sourceMappingURL=content.js.map

package/dist/native/blocks/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["../../../src/native/blocks/content.tsx"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,SAAS,EACT,wBAAwB,EACxB,OAAO,EACP,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAM7D,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEvD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAkC;IACzD,GAAG,YAAY;IACf,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAClD,KAAC,OAAO,IAAC,OAAO,EAAC,IAAI,YACnB,KAAC,SAAS,cACR,KAAC,cAAc,IACb,OAAO,EAAE,OAAO,IAAI,SAAS,EAC7B,KAAK,EAAE,KAAK,IAAI,SAAS,EACzB,WAAW,EAAE,WAAW,IAAI,SAAS,EACrC,KAAK,EAAE,KAAK,IAAI,OAAO,EACvB,IAAI,EAAC,IAAI,GACT,GACQ,GACJ,CACX;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAA+B;IACnD,GAAG,SAAS;IACZ,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAC3B,KAAC,OAAO,IAAC,OAAO,EAAC,IAAI,YACnB,KAAC,SAAS,cACR,KAAC,UAAU,IACT,IAAI,EAAC,SAAS,EACd,KAAK,EAAE,wBAAwB,CAAC,KAAK,IAAI,OAAO,CAAC,YAChD,IAAI,GACM,GACH,GACJ,CACX;CACF,CAAC"}

package/dist/native/blocks/layout.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The platform layout blocks.
+ *
+ * A band and a two-column arrangement. Both are the only blocks whose props hold a drop
+ * zone, and on the platform a drop zone is a rendered node rather than a component to
+ * place: the page renderer resolves a stored page's children before it calls a block, so
+ * the block receives what to draw. That is why these two props are declared here while
+ * every other block's come from the shared spec.
+ *
+ * One difference between the platforms is deliberate and stated rather than hidden. A
+ * two-column block offers a ratio on the web, where a stylesheet expresses one; the
+ * platform's grid resolves its own window and offers whole column counts, so the ratio
+ * resolves to the framework's two columns once there is room for them and the block
+ * draws the same arrangement at every width below that.
+ */
+import type { ReactNode } from "react";
+import type { AsheeBlock, ColumnsBandProps, SectionBandProps } from "../../shared";
+/**
+ * The props of the band block.
+ */
+export type SectionBlockProps = SectionBandProps & {
+    /** Content dropped into the band, already rendered. */
+    content?: ReactNode;
+};
+/**
+ * A band with its own vertical rhythm and background.
+ */
+export declare const sectionBlock: AsheeBlock<SectionBlockProps>;
+/**
+ * The props of the two-column block.
+ */
+export type ColumnsBlockProps = ColumnsBandProps & {
+    /** Content of the first column, already rendered. */
+    start?: ReactNode;
+    /** Content of the second column, already rendered. */
+    end?: ReactNode;
+};
+/**
+ * Two columns that stack on a narrow screen.
+ */
+export declare const columnsBlock: AsheeBlock<ColumnsBlockProps>;
+//# sourceMappingURL=layout.d.ts.map

package/dist/native/blocks/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/native/blocks/layout.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAGtB;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,uDAAuD;IACvD,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,iBAAiB,CAOtD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,qDAAqD;IACrD,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,sDAAsD;IACtD,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,iBAAiB,CAYtD,CAAC"}

package/dist/native/blocks/layout.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The platform layout blocks.
+ *
+ * A band and a two-column arrangement. Both are the only blocks whose props hold a drop
+ * zone, and on the platform a drop zone is a rendered node rather than a component to
+ * place: the page renderer resolves a stored page's children before it calls a block, so
+ * the block receives what to draw. That is why these two props are declared here while
+ * every other block's come from the shared spec.
+ *
+ * One difference between the platforms is deliberate and stated rather than hidden. A
+ * two-column block offers a ratio on the web, where a stylesheet expresses one; the
+ * platform's grid resolves its own window and offers whole column counts, so the ratio
+ * resolves to the framework's two columns once there is room for them and the block
+ * draws the same arrangement at every width below that.
+ */
+import { Container, Grid, Section } from "@asheeui/native";
+import { COLUMNS_SPEC, SECTION_SPEC } from "../../shared";
+/**
+ * A band with its own vertical rhythm and background.
+ */
+export const sectionBlock = {
+    ...SECTION_SPEC,
+    render: ({ spacing, background, content }) => (_jsx(Section, { spacing: spacing ?? "lg", background: background ?? "none", children: _jsx(Container, { children: content }) })),
+};
+/**
+ * Two columns that stack on a narrow screen.
+ */
+export const columnsBlock = {
+    ...COLUMNS_SPEC,
+    render: ({ spacing, start, end }) => (_jsx(Section, { spacing: spacing ?? "lg", children: _jsx(Container, { children: _jsxs(Grid, { columns: 1, columnsLg: 2, gap: "lg", children: [start, end] }) }) })),
+};
+//# sourceMappingURL=layout.js.map

package/dist/native/blocks/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../../src/native/blocks/layout.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAO3D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAU1D;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAkC;IACzD,GAAG,YAAY;IACf,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAC5C,KAAC,OAAO,IAAC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,UAAU,EAAE,UAAU,IAAI,MAAM,YACjE,KAAC,SAAS,cAAE,OAAO,GAAa,GACxB,CACX;CACF,CAAC;AAaF;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAkC;IACzD,GAAG,YAAY;IACf,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CACnC,KAAC,OAAO,IAAC,OAAO,EAAE,OAAO,IAAI,IAAI,YAC/B,KAAC,SAAS,cACR,MAAC,IAAI,IAAC,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,EAAC,IAAI,aACrC,KAAK,EACL,GAAG,IACC,GACG,GACJ,CACX;CACF,CAAC"}

package/dist/native/blocks/navigation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The platform navigation blocks.
+ *
+ * A bar and a footer, with the navigation as data: link lists a non-developer can edit
+ * and no application state. The bar's action region is the framework's own action group,
+ * so a configured action renders exactly as a hand-written button does and follows the
+ * destination through the platform's own URL handler. The fields and the defaults come
+ * from `src/shared`.
+ */
+import type { AsheeBlock, FooterBlockProps, NavbarBlockProps } from "../../shared";
+/**
+ * The navigation bar of a page.
+ */
+export declare const navbarBlock: AsheeBlock<NavbarBlockProps>;
+/**
+ * The footer of a page.
+ */
+export declare const footerBlock: AsheeBlock<FooterBlockProps>;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/native/blocks/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/native/blocks/navigation.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAGtB;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAAU,CAAC,gBAAgB,CA0BpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAAU,CAAC,gBAAgB,CAiBpD,CAAC"}