@dtkt/protoform 0.0.0-stage → 0.1.0

package/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.

package/README.md

@@ -1,3 +1,222 @@
-# Temporary Holding Version
+# @dtkt/protoform
 
-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.
+Generate editable forms from protobuf message descriptors. Built on
+[protobuf-es](https://github.com/bufbuild/protobuf-es) reflection and
+[protovalidate](https://github.com/bufbuild/protovalidate-es).
+
+```tsx
+import { Message } from "@dtkt/protoform";
+import { Protoform, SubmitButton } from "@dtkt/protoform/components";
+import { tailwindKit } from "@dtkt/protoform/kit/tailwind";
+import "@dtkt/protoform/styles.css";
+
+const message = new Message(MySchema, { name: "example" });
+
+<Protoform message={message} kit={tailwindKit} onSubmit={() => save(message.get())}>
+  <SubmitButton>Save</SubmitButton>
+</Protoform>
+```
+
+`SubmitButton` is drawn by the active kit, so it matches the form (and any kit you swap in).
+Other children of `<Protoform>` are rendered as-is: the kit styles only its own elements.
+
+`message.get()` is always the live protobuf message; edits apply immediately.
+`onSubmit` only fires when protovalidate passes and no input is unparsable
+(`onInvalid` fires otherwise). Errors show after the first submit attempt and
+stay current as the user edits (`validateOn="change"` shows them from the first edit).
+
+## Install
+
+```sh
+npm install @dtkt/protoform @bufbuild/protobuf @bufbuild/protovalidate react react-dom
+npm install @headlessui/react   # only if you use the Tailwind kit
+```
+
+`@headlessui/react` is an *optional* peer dependency: the bare kit doesn't need it, but
+`@dtkt/protoform/kit/tailwind` does, and **your app must install it** so it shares your copy of React.
+
+### Troubleshooting: `Cannot read properties of null (reading 'useId')`
+
+This means Headless UI is running against a second copy of React ("Invalid hook call").
+It happens when the library is **linked locally** (`npm link`, `file:`, workspaces): the
+bundler resolves the library's imports from its real path, so it picks up the library's own
+`node_modules` copies of `@headlessui/react` and `react` — even if your app has them
+installed. Force a single copy in `vite.config.ts`, then restart with `vite --force` and
+hard-reload:
+
+```ts
+export default defineConfig({
+  resolve: {
+    dedupe: [
+      "react", "react-dom", "@headlessui/react",
+      "@bufbuild/protobuf", "@bufbuild/protovalidate",
+      "@connectrpc/connect", "@connectrpc/connect-web",
+    ],
+  },
+});
+```
+
+Regular installs from a registry or a packed tarball (`npm pack`) don't need this, but your
+app must still install `@headlessui/react` for the Tailwind kit.
+
+## Annotations
+
+Protoform works with any generated protobuf type; annotations only refine the defaults.
+The `dtkt.protoform.v1beta1` annotation schema ships with this package (like
+`@bufbuild/protovalidate/gen` does for `buf.validate`), so your own generated code can
+use it without depending on `@dtkt/sdk`. With `buf.gen.yaml`:
+
+```yaml
+- remote: buf.build/bufbuild/es
+  opt:
+    - map_imports=dtkt/protoform/:@dtkt/protoform/gen
+```
+
+`@bufbuild/protobuf` and `@bufbuild/protovalidate` are peer dependencies so your generated
+code, protovalidate and Protoform share a single copy.
+
+## What each type renders
+
+| Proto type | Control |
+|---|---|
+| `string` | text input (`input.multilineText` hint → textarea) |
+| `bool` | switch (`confirm` hint → checkbox) |
+| `int32` family | text input, `inputmode=numeric`, range-checked |
+| `int64` family | same, kept exact as `bigint` |
+| `float`, `double` | text input, accepts `NaN`/`Infinity` |
+| `bytes` | base64 text (`file` hint → file picker) |
+| `enum` | radio group (≤ 4 values) or select |
+| `message` | collapsible section, added/removed explicitly (unset ≠ empty) |
+| `repeated` | rows with add, remove, move up/down |
+| `map` | rows labelled by key; key input validated for the key type, duplicates rejected |
+| `oneof` | case picker plus the selected member |
+| `Timestamp`, `Duration`, `FieldMask` | RFC 3339 / `1.5s` / `a,b.c` text with validation (Timestamp has a "Now" button) |
+| `Struct`, `Value`, `ListValue` | JSON editor |
+| wrappers (`Int32Value`, …) | the wrapped scalar |
+| `Any` | type picker from the `Env` registry, then the nested form |
+
+The `select` / `multiSelect` hints (options loaded over RPC) are not implemented yet; those fields fall back to the control for their type.
+
+## Choosing a UI
+
+Rendering goes through a `UIKit`: a small set of primitives (`Form`, `Stack`,
+`Row`, `Field`, `Section`, `TextInput`, `TextArea`, `Checkbox`, `Select`,
+`RadioGroup`, `FileInput`, `Button`). Three levels:
+
+1. **Tailwind + Headless UI** — `@dtkt/protoform/kit/tailwind` plus `@dtkt/protoform/styles.css`.
+   `@headlessui/react` is an optional peer dependency; Tailwind is *not* required in your app.
+2. **Bare** (the default when no kit is given) — unstyled, semantic HTML with `data-pf="…"`
+   attributes to style against. No CSS, no extra dependencies.
+3. **Your own** — pass any subset of primitives; the rest fall back to the enclosing
+   provider or the bare kit.
+
+```tsx
+import { UIProvider } from "@dtkt/protoform/providers";
+
+// Use MUI buttons everywhere, everything else bare
+<UIProvider kit={{ Button: ({ children, onClick, disabled, type }) => (
+  <MuiButton type={type} onClick={onClick} disabled={disabled}>{children}</MuiButton>
+) }}>
+  <Protoform message={message} />
+</UIProvider>
+```
+
+`<Protoform kit={…}>` takes the same `kit`, `renderers`, `resolve` and `messages`
+props as `UIProvider`. Providers nest; inner ones override per primitive.
+`defineKit(a, b)` composes kits over the bare kit.
+
+### Theming and dark mode
+
+`styles.css` is prebuilt: no Tailwind setup or global reset, only `.pf-*` classes in
+the `protoform` cascade layer (your own unlayered CSS wins). Retheme with CSS custom
+properties on the form or any ancestor:
+
+```css
+.my-form { --pf-accent: #0d9488; --pf-radius: 0.75rem; }
+```
+
+The form uses a system sans-serif font by default. To use your own stack, set
+`--pf-font: "Inter", sans-serif;` on the form or any ancestor. To follow your app's
+typography, use plain CSS (unlayered CSS beats the `protoform` layer):
+
+```css
+.pf-form { font-family: inherit; }
+```
+
+(`--pf-font: inherit` does *not* work: for a custom property, `inherit` means "take the
+parent's `--pf-font`", not "inherit `font-family`".)
+
+Dark mode follows `prefers-color-scheme`. Force it with `.dark` / `[data-theme="dark"]`
+(or `.light` / `[data-theme="light"]`) on the form or any ancestor.
+
+### Custom renderers
+
+Replace the editor for individual fields without touching the kit. Keys are a
+field's full name (`pkg.Message.field`) or the type name of its message/enum:
+
+```tsx
+const TimestampPicker: FieldRenderer = ({ field, id }) => <MyDatePicker id={id} field={field} />;
+
+<Protoform
+  message={message}
+  renderers={{ "google.protobuf.Timestamp": TimestampPicker }}
+  resolve={(field) => field.desc.name === "secret" ? SecretInput : undefined}
+/>
+```
+
+A renderer is wrapped in the standard labelled field frame; set `Renderer.frame = "none"`
+to draw your own (see `FieldSection`).
+
+### Translating
+
+All built-in strings live in `defaultMessages`; override any with the `messages` prop.
+
+## Environment
+
+`Env` (via `EnvProvider`) supplies the type registry (needed for `Any`), validator and
+transport. The default transport is created lazily, so importing the package has no side effects.
+
+```tsx
+const env = new Env({ registry, anyTypeFilter: (name) => name.startsWith("acme.") });
+```
+
+## Development
+
+### Playground
+
+An interactive playground lives in [`playground/`](./playground). It renders a form for a
+fixture message covering every field type, with live JSON output beside it, and toggles for
+kit (Tailwind / bare), theme (system / light / dark) and read-only mode.
+
+```sh
+npm install
+npm run dev        # → http://localhost:5173
+```
+
+Edits to `lib/` (components, kits, `lib/styles/protoform.css`) hot-reload. To try your own
+message, change what `playground/main.tsx` renders — the fixture schema is in
+`lib/test/fixture.ts`, or import any generated schema from your own protos.
+
+`npm run build` produces the publishable package in `dist/`. (There is no `vite preview`
+target: the build is a library, not an app. Use the playground to see it.)
+
+### Scripts
+
+```sh
+npm run dev            # playground with HMR
+npm test               # vitest (jsdom), single run
+npm run test:watch     # vitest in watch mode
+npm run test:coverage  # coverage report (v8) in the terminal and ./coverage
+npm run lint           # eslint
+npm run gen            # regenerate lib/gen (annotation schemas) from buf.build/datakit-dev/dtkt-sdk
+npm run build          # tsc, library (vite), then dist/styles.css (tailwind CLI)
+```
+
+### Tests
+
+Tests are co-located with the code they cover (`foo.ts` → `foo.test.ts`,
+`components/foo.tsx` → `components/foo.test.tsx`). Shared helpers live in
+[`lib/test/`](./lib/test): `fixture.ts` builds a schema at runtime covering every field type
+plus annotated ("hinted") fields, `render.tsx` renders a form with an `Env`, and
+`helpers.ts` has the typed data accessors. UI tests run against **every shipped kit**
+(`describe.each(kits)`), so a new kit or primitive is exercised by the whole suite.

package/dist/base.d.ts

@@ -0,0 +1,19 @@
+import { DescField } from '@bufbuild/protobuf';
+import { Violation } from '@bufbuild/protovalidate';
+import { Element } from './element';
+import { Field } from './field';
+import { Message } from './message';
+/** Shared behavior for fields that live inside a parent `Message`. */
+export declare abstract class BaseField<D extends DescField> implements Field {
+    readonly parent: Message;
+    readonly desc: D;
+    readonly path: string;
+    readonly elem: Element;
+    constructor(parent: Message, desc: D);
+    get errors(): Violation[];
+    errorMessages(): string[];
+    /** Marks the underlying message as changed so subscribed UI re-renders. */
+    protected changed(): void;
+    abstract toString(): string;
+    abstract parse(value: string): void;
+}

package/dist/comments.d.ts

@@ -0,0 +1,9 @@
+import { DescEnum, DescEnumValue, DescField, DescMessage, DescOneof } from '@bufbuild/protobuf';
+export type Commentable = DescMessage | DescEnum | DescEnumValue | DescField | DescOneof;
+export type Comments = {
+    leadingDetached: string[];
+    leading?: string;
+    trailing?: string;
+};
+/** Comments attached to a descriptor in the .proto source, if the descriptor carries source info. */
+export declare function getComments(desc: Commentable): Comments;

package/dist/components/enum.d.ts

@@ -0,0 +1,24 @@
+import { DescEnum } from '@bufbuild/protobuf';
+import { EnumField } from '../enum';
+import { FieldElementProps } from './field';
+export type EnumInputProps = {
+    desc: DescEnum;
+    value: number;
+    onValue: (value: number) => void;
+    id?: string;
+    name?: string;
+    describedBy?: string;
+    invalid?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    /** Always use a select (e.g. inside list rows). */
+    compact?: boolean;
+    "aria-label"?: string;
+};
+/** An editor for a single enum value; usable standalone (e.g. list items). */
+export declare function EnumInput({ desc, value, onValue, compact, ...control }: EnumInputProps): import('react').JSX.Element;
+type EnumElementProps = FieldElementProps & {
+    field: EnumField;
+};
+export declare function EnumElement({ field, mode, id, describedBy, invalid }: EnumElementProps): import('react').JSX.Element;
+export {};

package/dist/components/field.d.ts

@@ -0,0 +1,16 @@
+import { Field } from '../field';
+/** `view` is read-only; `edit` and `auto` are editable (changes apply immediately). */
+export type FieldDisplayMode = "edit" | "view" | "auto";
+export type FieldElementProps = {
+    field: Field;
+    mode?: FieldDisplayMode;
+    depth?: number;
+    /** Id for the control, so a surrounding label can point at it. */
+    id?: string;
+    /** Id(s) of the description/error elements for `aria-describedby`. */
+    describedBy?: string;
+    invalid?: boolean;
+};
+/** Renders the editor for a field: a custom renderer if one matches, else the built-in. */
+export declare function FieldElement(props: FieldElementProps): import('react').JSX.Element;
+export declare function BuiltinFieldElement(props: FieldElementProps): import('react').JSX.Element | null;

package/dist/components/frame.d.ts

@@ -0,0 +1,6 @@
+import { Field } from '../field';
+/**
+ * Whether a field is rendered inside a labelled `Field` frame (single
+ * controls) or draws its own `Section` (lists, maps, messages, oneofs).
+ */
+export declare function frameOf(field: Field): "field" | "section";

package/dist/components/group.d.ts

@@ -0,0 +1,25 @@
+import { PropsWithChildren, ReactNode } from 'react';
+import { Field } from '../field';
+import { FieldDisplayMode } from './field';
+export type FieldGroupProps = {
+    fields: Field[];
+    mode?: FieldDisplayMode;
+    depth?: number;
+};
+export declare function FieldGroup({ fields, mode, depth, }: FieldGroupProps): import('react').JSX.Element;
+export type FieldRowProps = {
+    field: Field;
+    mode?: FieldDisplayMode;
+    depth?: number;
+};
+/** Renders one field with its label, description and errors. */
+export declare function FieldRow({ field, mode, depth }: FieldRowProps): import('react').JSX.Element;
+export type FieldSectionProps = PropsWithChildren<{
+    field: Field;
+    depth?: number;
+    id?: string;
+    actions?: ReactNode;
+    collapsible?: boolean;
+}>;
+/** Frames the body of a composite field (message, list, map, oneof) with its title and errors. */
+export declare function FieldSection({ field, depth, id, actions, collapsible, children }: FieldSectionProps): import('react').JSX.Element;

package/dist/components/hooks.d.ts

@@ -0,0 +1,18 @@
+import { Message } from '../message';
+/**
+ * Subscribes to a message tree. Components that edit a `Message` re-render
+ * whenever its data or errors change. `Protoform` does this for you.
+ */
+export declare function useMessage(message: Message): Message;
+/**
+ * Keeps what the user typed while it is not yet (or no longer exactly) the
+ * canonical text of the value, so typing "1." or "-" isn't clobbered.
+ *
+ * `normalize` maps typed text to its canonical form, or `undefined` if the
+ * text is invalid.
+ */
+export declare function useDraft(canonical: string, normalize: (text: string) => string | undefined): {
+    text: string;
+    setText: (next: string) => void;
+    reset: () => void;
+};

package/dist/components/index.d.ts

@@ -0,0 +1,13 @@
+export * from './enum';
+export * from './field';
+export * from './frame';
+export * from './group';
+export * from './hooks';
+export * from './list';
+export * from './map';
+export * from './message';
+export * from './oneof';
+export * from './protoform';
+export * from './scalar';
+export * from './submit';
+export * from './wkt';

package/dist/components/index.js

@@ -0,0 +1,14 @@
+import { a as e } from "../context-DSrebuNf.js";
+import { C as t, _ as n, a as r, c as i, d as a, f as o, g as s, h as c, i as l, l as u, m as d, n as f, o as p, p as m, r as h, s as g, t as _, u as v, v as y, w as b } from "../protoform-DmMJ7LSw.js";
+import { jsx as x } from "react/jsx-runtime";
+// lib/components/submit.tsx
+function S({ variant: t = "primary", children: n = "Submit", ...r }) {
+	let { Button: i } = e();
+	return /* @__PURE__ */ x(i, {
+		...r,
+		variant: t,
+		type: "submit",
+		children: n
+	});
+}
+export { m as AnyEditor, p as BuiltinFieldElement, t as EnumElement, b as EnumInput, g as FieldElement, f as FieldGroup, h as FieldRow, l as FieldSection, v as ListElement, u as MapElement, a as MessageElement, o as MessageValue, i as OneOfFieldElement, _ as Protoform, c as ScalarElement, s as ScalarInput, S as SubmitButton, d as WellKnownEditor, r as frameOf, n as useDraft, y as useMessage };

package/dist/components/list.d.ts

@@ -0,0 +1,7 @@
+import { ListField } from '../list';
+import { FieldElementProps } from './field';
+type ListElementProps = FieldElementProps & {
+    field: ListField;
+};
+export declare function ListElement({ field, mode, depth, id }: ListElementProps): import('react').JSX.Element;
+export {};

package/dist/components/map.d.ts

@@ -0,0 +1,7 @@
+import { MapField } from '../map';
+import { FieldElementProps } from './field';
+type MapElementProps = FieldElementProps & {
+    field: MapField;
+};
+export declare function MapElement({ field, mode, depth, id }: MapElementProps): import('react').JSX.Element;
+export {};

package/dist/components/message.d.ts

@@ -0,0 +1,17 @@
+import { Message, MessageField } from '../message';
+import { FieldDisplayMode, FieldElementProps } from './field';
+export type MessageValueProps = {
+    message: Message;
+    mode?: FieldDisplayMode;
+    depth?: number;
+    id?: string;
+    describedBy?: string;
+    invalid?: boolean;
+    "aria-label"?: string;
+};
+/** The editor for the contents of a message (a form, or a specialised well-known type editor). */
+export declare function MessageValue({ message, mode, depth, ...control }: MessageValueProps): import('react').JSX.Element;
+export type MessageElementProps = FieldElementProps & {
+    field: MessageField;
+};
+export declare function MessageElement({ field, mode, depth, id, describedBy, invalid }: MessageElementProps): import('react').JSX.Element;

package/dist/components/oneof.d.ts

@@ -0,0 +1,8 @@
+import { OneOfField } from '../oneof';
+import { FieldElementProps } from './field';
+type OneOfFieldElementProps = FieldElementProps & {
+    field: OneOfField;
+};
+/** A case picker plus the editor for the selected member. */
+export declare function OneOfFieldElement({ field, mode, depth, id }: OneOfFieldElementProps): import('react').JSX.Element;
+export {};

package/dist/components/protoform.d.ts

@@ -0,0 +1,20 @@
+import { PropsWithChildren, SubmitEvent } from 'react';
+import { Message } from '../message';
+import { UIProviderProps } from '../providers/ui';
+import { FieldDisplayMode } from './field';
+export type ProtoformProps = UIProviderProps & {
+    message: Message;
+    /** `view` makes the form read-only. */
+    mode?: FieldDisplayMode;
+    /**
+     * When to show validation errors. Errors always appear (and then stay
+     * current) after a submit attempt; `"change"` also validates from the
+     * first edit.
+     */
+    validateOn?: "load" | "change" | "submit";
+    /** Called on submit when the message is valid. */
+    onSubmit?: (event: SubmitEvent<HTMLFormElement>) => void;
+    /** Called on submit when validation fails or an input can't be parsed. */
+    onInvalid?: () => void;
+};
+export declare function Protoform({ kit, renderers, resolve, messages, ...props }: PropsWithChildren<ProtoformProps>): import('react').JSX.Element;