react-luna-form 0.0.4 → 0.0.6

package/dist/types/{util → luna-core/src/util}/constant.d.ts

@@ -1,14 +1,22 @@
 export declare const INPUT = "input";
 export declare const INPUT_EMAIL = "input/email";
 export declare const INPUT_NUMBER = "input/number";
-export declare const INPUT_TEXTAREA = "textarea";
-export declare const COLUMN = "column";
-export declare const FIELDS = "fields";
+export declare const INPUT_PASSWORD = "input/password";
+export declare const INPUT_TEL = "input/tel";
+export declare const INPUT_TEXT = "input/text";
+export declare const INPUTS: string[];
+export declare const TEXTAREA = "textarea";
 export declare const RADIO = "radio";
-export declare const VALUE = "value";
+export declare const CHECKBOX = "checkbox";
 export declare const SELECT = "select";
 export declare const SELECT_MONTH = "select/month";
 export declare const SELECT_YEAR = "select/year";
+export declare const SELECTS: string[];
+export declare const COLUMN = "column";
+export declare const FIELDS = "fields";
+export declare const LABEL = "label";
+export declare const VALUE = "value";
+export declare const OPTIONS = "options";
 export declare const TYPE_EMAIL = "email";
 export declare const TYPE_NUMBER = "number";
 export declare const TYPE_PASSWORD = "password";
@@ -17,9 +25,16 @@ export declare const TYPE_TEXT = "text";
 export declare const ARIA_ERROR_MESSAGE = "aria-errormessage";
 export declare const ARIA_INVALID = "aria-invalid";
 export declare const DATA_INVALID = "data-invalid";
+export declare const DATA_READONLY = "data-readonly";
 export declare const PREFIX_ARIA = "aria";
 export declare const PREFIX_DATA = "data";
 export declare const MIN = "min";
 export declare const MAX = "max";
 export declare const MIN_LENGTH = "minLength";
 export declare const MAX_LENGTH = "maxLength";
+export declare const $REF = "$ref";
+export declare const SOURCE = "source";
+export declare const SET = "set";
+export declare const COMMON_URL = "http://luna.internal";
+export declare const VERTICAL = "vertical";
+export declare const HORIZONTAL = "horizontal";

package/dist/types/{util → luna-core/src/util}/extract.d.ts

@@ -1,6 +1,14 @@
-import type { Nullable, Value } from '../type';
+import type { Nullable, Option, Value } from '../type';
+export declare function getEntity<T>(selected: string, collection?: Nullable<T[]>, entity?: string): NonNullable<T> | {
+    value: string;
+} | undefined;
 export declare function getCurrentValue<T>(value: T, entity?: string): Value | undefined;
 export declare function getValue<T>(value: Record<string, T>, namespace?: string): T | undefined;
 export declare function getArray<T>(value: Record<string, T> | T[], namespace?: string): Nullable<T[]>;
 export declare function extract<T>(value: Record<string, T>, namespace?: string): T | null;
+export declare function toOptions<T>(data: T[], options?: Option): (T | {
+    label: string;
+    value: string;
+})[];
 export declare function getType(value?: string): string;
+export declare function getFormData(formData: FormData): Record<string, unknown>;

package/dist/types/luna-core/src/util/is-input.d.ts

@@ -0,0 +1,17 @@
+import type { Column, Field, Input, Nullable, Select } from '../type';
+export declare const isSelectMonth: (field: Field) => boolean;
+export declare const isSelectYear: (field: Field) => boolean;
+export declare const isCheckbox: (field: Field) => field is Input;
+export declare const isInput: (field: Field) => field is Input;
+export declare const isRadio: (field: Field) => field is Select;
+export declare const isSelect: (field: Field) => field is Select;
+export declare const isTextArea: (field: Field) => field is Input;
+export declare const isText: (field: Field) => field is Input;
+export declare const isEmail: (field: Field) => field is Input;
+export declare const isNumber: (field: Field) => field is Input;
+export declare function isClickable(field: Field): boolean;
+export declare function isColumn(slot: Field | Column): slot is Column;
+export declare function isField(slot: Field | Column): slot is Field;
+export declare function isOptions(field: Field): field is Input;
+export declare function isTextable(field: Field): boolean;
+export declare function isValidValue<T>(value?: Nullable<T>): boolean;

package/dist/types/luna-core/src/util/is-type.d.ts

@@ -0,0 +1,6 @@
+import type { DataSource, Value } from '../type';
+export declare function isObject<T>(value: unknown): value is Record<string, T>;
+export declare function isEmpty(value: unknown): boolean;
+export declare function isValue(value: unknown): value is Value;
+export declare function isString(value: unknown): value is string;
+export declare function isDataSource(value: unknown): value is DataSource;

package/dist/types/luna-core/src/util/prepare.d.ts

@@ -0,0 +1,4 @@
+import type { Base, Definition, Nullable } from '../type';
+export declare function prepare<T extends Base>(base?: readonly T[], definition?: Definition): any[];
+export declare function resolveRefs(base: unknown, definition?: Definition, cache?: Map<object, unknown>, visited?: WeakSet<object>): unknown;
+export declare function entries<T>(values?: Nullable<Record<string, T>>): [key: string, value: T][];

package/dist/types/luna-core/src/util/schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Input, Schemas } from '../type';
+export declare function buildSchema(schemas: Schemas): z.ZodObject<{
+    [x: string]: import("..").Schema;
+}, z.core.$strip>;
+export declare function flatten(error: z.ZodError<Record<string, unknown>>): Record<string, string[]>;
+export declare function getSchema(input: Input): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+export declare function getEmail(input: Input): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodPipe<z.ZodString, z.ZodEmail>> | z.ZodNullable<z.ZodUnion<[z.ZodPipe<z.ZodString, z.ZodEmail>, z.ZodLiteral<"">]>>;
+export declare function getBoolean(input: Input): z.ZodPipe<z.ZodTransform<{} | undefined, unknown>, z.ZodCoercedBoolean<unknown>> | z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+export declare function getRadio(input: Input): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedString<unknown>> | z.ZodNullable<z.ZodUnion<[z.ZodCoercedString<unknown>, z.ZodLiteral<"">]>>;
+export declare function getText(input: Input): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedString<unknown>> | z.ZodNullable<z.ZodCoercedString<unknown>>;
+export declare function getNumber(input: Input): z.ZodPipe<z.ZodTransform<{} | undefined, unknown>, z.ZodCoercedNumber<unknown>> | z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+export declare function getYearSchema(input: Input): z.ZodPipe<z.ZodTransform<{} | undefined, unknown>, z.ZodCoercedNumber<unknown>> | z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+export declare function getMonthSchema(input: Input): z.ZodCoercedNumber<unknown> | z.ZodNullable<z.ZodCoercedNumber<unknown>>;

package/dist/types/luna-core/src/util/source.d.ts

@@ -0,0 +1,2 @@
+import type { DataSource, Nullable } from '../type';
+export declare function mergeSource(sources: DataSource[]): Nullable<DataSource>;

package/dist/types/luna-core/src/util/string.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Replaces placeholders in the format {key} with values from the provided object.
+ * Supports nested objects using dot notation (e.g., {user.id}).
+ */
+export declare function interpolate<T>(template: T, values?: Record<string, unknown>): T;
+export declare function isInterpolated(template: unknown): boolean;
+export declare function formatMarkdown<K>(text?: string, callback?: (index: number, url: string, text?: string) => K): (string | K)[] | string | null;

package/dist/types/luna-core/src/util/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringify<T>(body: T): string | null;

package/dist/types/luna-core/src/util/url.d.ts

@@ -0,0 +1,10 @@
+import type { RemotePattern } from '../type';
+/**
+ * Validates a URL against a list of allowed remote patterns.
+ * Internal URLs are allowed by default.
+ * If patterns is undefined, all URLs are allowed.
+ * If patterns is an empty array, all external URLs are blocked.
+ */
+export declare function matchRemotePattern(urlStr: string, patterns?: RemotePattern[]): boolean;
+export declare function isExternalUrl(url: string): boolean;
+export declare function mergeUrl(baseUrl: string, targetUrl: string): string;

package/dist/types/luna-react/src/client/component/form.d.ts

@@ -0,0 +1,14 @@
+import { type FormState } from '../hook/use-form-action';
+import type { Definition, FormStateError, Nullable, Sections, ZodSchema } from '@luna-form/core';
+import type { Config } from '../../type';
+export declare function Form<T extends Record<string, unknown> = Record<string, unknown>>(props: Readonly<{
+    action?: (formData: unknown, schema?: ZodSchema) => Promise<FormState<T>>;
+    children?: React.ReactNode;
+    config: Config;
+    definition?: Definition;
+    onError?: (error: Nullable<FormStateError>) => void;
+    onSuccess?: (data: T) => void;
+    readOnly?: boolean;
+    sections: Sections;
+    value?: Nullable<T>;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{client → luna-react/src/client}/component/input.d.ts

@@ -1,4 +1,5 @@
-import type { AriaAttributes, CommonProps, Config, DataAttributes, Field, Schema, Source } from '../../type';
+import { type AriaAttributes, type CommonProps, type DataAttributes, type Field, type Nullable, type Schema } from '@luna-form/core';
+import type { Config } from '../../type';
 export declare function Input(props: Readonly<{
     ariaAttributes?: AriaAttributes;
     commonProps: CommonProps;
@@ -7,7 +8,5 @@ export declare function Input(props: Readonly<{
     field: Field;
     onMount: (name: string, schema: Schema) => void;
     onUnmount: (name: string) => void;
-    source?: Source;
-    value?: Record<string, unknown>;
-    withinColumn?: boolean;
-}>): import("react/jsx-runtime").JSX.Element | null;
+    value?: Nullable<Record<string, unknown>>;
+}>): import("react").ReactNode;

package/dist/types/{component/slot → luna-react/src/client/component}/slot.d.ts

@@ -1,4 +1,5 @@
-import type { Children, Fields } from '../../type';
+import type { Children } from '../../type';
+import type { Fields } from '@luna-form/core';
 export declare const Slot: (props: Readonly<{
     children: Children;
     disabled?: boolean;

package/dist/types/{client/component/wrapper/field.d.ts → luna-react/src/client/component/wrapper/index.d.ts}

@@ -2,6 +2,5 @@ export declare const Field: (props: Readonly<Omit<Readonly<{
     children: import("../../../type").Children;
     disabled?: boolean;
     errors?: Record<string, string[]>;
-    field: import("../../../type").Field;
-    withinColumn?: boolean;
+    field: import("@luna-form/core").Field;
 }>, "errors">>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/client/hook/use-data-source.d.ts

@@ -0,0 +1,3 @@
+import { type Field, type Nullable } from '@luna-form/core';
+import type { Config } from '../../type';
+export declare function useDataSource(field: Field, config: Config, value?: Nullable<Record<string, unknown>>): readonly [Nullable<unknown[]>, (target: string, value: import("@luna-form/core").DataSource | undefined) => void];

package/dist/types/luna-react/src/client/hook/use-fetch.d.ts

@@ -0,0 +1,3 @@
+import { type DataSource, type Nullable } from '@luna-form/core';
+import type { Config } from '../../type';
+export declare function useFetch<T>(dataSource: Nullable<DataSource | T[]> | undefined, config: Config, disabled?: boolean): [Nullable<T[]>];

package/dist/types/luna-react/src/client/hook/use-form-action.d.ts

@@ -0,0 +1,14 @@
+import { type FormStateError, type Nullable, type Schemas, type ZodSchema } from '@luna-form/core';
+export type FormState<T> = {
+    data: Nullable<T>;
+    error: Nullable<FormStateError>;
+    success: boolean;
+};
+export type FormActionOptions<T> = {
+    onError?: (error: Nullable<FormStateError>) => void;
+    onSuccess?: (data: T) => void;
+    preserveValues?: boolean;
+    validation?: boolean;
+    value?: Nullable<T>;
+};
+export declare function useFormState<T>(getSchema: () => Schemas, action?: <K>(formData: K, schema?: ZodSchema) => Promise<FormState<T>>, options?: FormActionOptions<T>): readonly [(payload: FormData) => void, FormState<T>, boolean];

package/dist/types/{client/hook/useInput.d.ts → luna-react/src/client/hook/use-input.d.ts}

@@ -1,2 +1,2 @@
-import type { Field, Schema } from '../../type';
+import type { Field, Schema } from '@luna-form/core';
 export declare function useInput(field: Field, onMount: (name: string, schema: Schema) => void, onUnmount: (name: string) => void): readonly [import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>];

package/dist/types/{client/hook/useSchema.d.ts → luna-react/src/client/hook/use-schema.d.ts}

@@ -1,2 +1,2 @@
-import type { Schema, Schemas } from '../../type';
+import type { Schema, Schemas } from '@luna-form/core';
 export declare function useSchema(): readonly [() => Schemas, (name: string, schema: Schema) => void, (name: string) => void];

package/dist/types/luna-react/src/client/hook/use-store.d.ts

@@ -0,0 +1 @@
+export declare function useStore(): (names: string | string[]) => void;

package/dist/types/luna-react/src/client/hook/use-timeout.d.ts

@@ -0,0 +1 @@
+export declare function useTimeout(): readonly [(callback: () => void, delay: number) => void, () => void];

package/dist/types/{client → luna-react/src/client}/index.d.ts

@@ -1,3 +1,3 @@
 import { Form } from './component/form';
 export { Form };
-export type { Sections, Source } from '../type';
+export type { Sections, Source } from '@luna-form/core';

package/dist/types/luna-react/src/client/lib/error-store.d.ts

@@ -0,0 +1,10 @@
+export declare const inputErrorAtom: import("jotai").PrimitiveAtom<Record<string, string[]>> & {
+    init: Record<string, string[]>;
+};
+export declare const clearInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
+export declare const reportErrorAtom: import("jotai").WritableAtom<null, [newValue: Record<string, string[]>], void> & {
+    init: null;
+};
+export declare const reportInputErrorAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<string[] | undefined, [newValue: string[] | undefined], void>>;

package/dist/types/luna-react/src/client/lib/source-store.d.ts

@@ -0,0 +1,8 @@
+import { type DataSource } from '@luna-form/core';
+export declare const sourceAtom: import("jotai").PrimitiveAtom<Record<string, Record<string, DataSource>>> & {
+    init: Record<string, Record<string, DataSource>>;
+};
+export declare const reportSourceAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<DataSource | undefined, [target: string, value: DataSource | undefined], void>>;
+export declare const clearInputSourceAtom: import("jotai").WritableAtom<null, [contributorNames: string[]], void> & {
+    init: null;
+};

package/dist/types/luna-react/src/client/lib/store-helper.d.ts

@@ -0,0 +1,21 @@
+import { type PrimitiveAtom } from 'jotai';
+type RecordValue<T> = T extends Record<string, infer V> ? V : never;
+interface NestedAtomFamilyOptions<TInner> {
+    merge?: (values: TInner[]) => TInner | undefined;
+    validateTarget?: (target: string) => boolean;
+}
+export declare function createRecordAtomFamily<TRecord extends Record<string, unknown>, TValue = RecordValue<TRecord>>(baseAtom: PrimitiveAtom<TRecord>): import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<NonNullable<TValue> | undefined, [newValue: TValue | undefined], void>>;
+export declare function createClearAllAtom<T>(baseAtom: PrimitiveAtom<Record<string, T>>): import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+export declare function createClearAtom<T>(baseAtom: PrimitiveAtom<Record<string, T>>): import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
+export declare function createBulkReportAtom<T>(baseAtom: PrimitiveAtom<Record<string, T>>): import("jotai").WritableAtom<null, [newValue: Record<string, T>], void> & {
+    init: null;
+};
+export declare function createNestedRecordAtomFamily<TInner, TRecord extends Record<string, Record<string, TInner>> = Record<string, Record<string, TInner>>>(baseAtom: PrimitiveAtom<TRecord>, options?: NestedAtomFamilyOptions<TInner>): import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<TInner | undefined, [target: string, value: TInner | undefined], void>>;
+export declare function createNestedClearAtom<TInner>(baseAtom: PrimitiveAtom<Record<string, Record<string, TInner>>>): import("jotai").WritableAtom<null, [contributorNames: string[]], void> & {
+    init: null;
+};
+export {};

package/dist/types/luna-react/src/client/lib/value-store.d.ts

@@ -0,0 +1,13 @@
+export declare const valueAtom: import("jotai").PrimitiveAtom<Record<string, unknown>> & {
+    init: Record<string, unknown>;
+};
+export declare const clearAllValueAtom: import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+export declare const clearInputValueAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+    init: null;
+};
+export declare const reportBulkValueAtom: import("jotai").WritableAtom<null, [newValue: Record<string, unknown>], void> & {
+    init: null;
+};
+export declare const reportValueAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<{} | undefined, [newValue: unknown], void>>;

package/dist/types/{component → luna-react/src/component}/column.d.ts

@@ -1,7 +1,6 @@
-import type { Column } from '../type';
+import { type Column } from '@luna-form/core';
 export type ColumnProps = Readonly<{
     children?: React.ReactNode;
     column?: Column;
-    errors?: Record<string, string[]>;
 }>;
 export declare function Column(props: ColumnProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component}/description.d.ts

@@ -1,3 +1,3 @@
 export declare function Description(props: Readonly<{
-    children: string;
+    children: string | React.ReactNode;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/component/field/field-base.d.ts

@@ -0,0 +1,10 @@
+import { type Orientation } from '@luna-form/core';
+export type FieldBaseProps = Readonly<{
+    children: React.ReactNode;
+    className?: string;
+    cols?: number;
+    disabled?: boolean;
+    errors?: string[];
+    orientation: Orientation;
+}>;
+export declare function FieldBase(props: FieldBaseProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component/field}/field-error.d.ts

@@ -1,4 +1,4 @@
-import type { Nullable } from '../type';
+import type { Nullable } from '@luna-form/core';
 export declare function FieldError(props: Readonly<{
     errors?: Nullable<string[]>;
     name?: string;

package/dist/types/luna-react/src/component/field/field-group.d.ts

@@ -0,0 +1,8 @@
+import { type Orientation } from '@luna-form/core';
+export declare function FieldGroup(props: Readonly<{
+    children: React.ReactNode;
+    cols?: number;
+    errors?: string[];
+    orientation?: Orientation;
+    disabled?: boolean;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/component/field/field-horizontal.d.ts

@@ -0,0 +1,6 @@
+export declare function FieldHorizontal(props: Readonly<{
+    children: React.ReactNode;
+    cols?: number;
+    disabled?: boolean;
+    errors?: string[];
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component/field}/field-set.d.ts

@@ -1,5 +1,5 @@
+import type { Section } from '@luna-form/core';
 export declare function FieldSet(props: Readonly<{
     children?: React.ReactNode;
-    description?: string;
-    title?: string;
+    section: Section;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/component/field/field-vertical.d.ts

@@ -0,0 +1,6 @@
+export declare function FieldVertical(props: Readonly<{
+    children: React.ReactNode;
+    cols?: number;
+    disabled?: boolean;
+    errors?: string[];
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component/field}/field.d.ts

@@ -1,9 +1,9 @@
-import type { Children, Field } from '../type';
+import { type Field } from '@luna-form/core';
+import type { Children } from '../../type';
 export type FieldProps = Readonly<{
     children: Children;
     disabled?: boolean;
     errors?: Record<string, string[]>;
     field: Field;
-    withinColumn?: boolean;
 }>;
 export declare function Field(props: FieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component}/form.d.ts

@@ -1,8 +1,11 @@
-import type { Sections, Slot } from '../type';
+import { type Definition, type Sections } from '@luna-form/core';
+import type { Config, Slot } from '../type';
 export declare function Form(props: Readonly<{
     action?: (formData: FormData) => void;
     children: Slot;
+    config: Config;
     control?: React.ReactNode;
+    definition?: Definition;
     noValidate?: boolean;
     readOnly?: boolean;
     sections: Sections;

package/dist/types/luna-react/src/component/formatted-description.d.ts

@@ -0,0 +1,3 @@
+export declare function FormattedDescription(props: Readonly<{
+    text?: string;
+}>): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/{component → luna-react/src/component}/group.d.ts

@@ -1,3 +1,4 @@
 export declare function Group(props: Readonly<{
     children?: React.ReactNode;
+    compact?: boolean;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component}/input/input-attributes.d.ts

@@ -1,3 +1,3 @@
-import type { Field } from '../../type';
+import { type Field } from '@luna-form/core';
 export declare function buildAriaAttributes(field: Field, errors?: string[]): Record<string, string | number | boolean>;
 export declare function buildDataAttributes(field: Field): Record<string, string | number | boolean>;

package/dist/types/{component → luna-react/src/component}/input/input-base.d.ts

@@ -1,8 +1,8 @@
-import type { Children, Field } from '../../type';
+import type { Children } from '../../type';
+import type { Field } from '@luna-form/core';
 export declare function InputBase(props: Readonly<{
     children: Children;
     disabled?: boolean;
     errors?: string[];
     field: Field;
-    withinColumn?: boolean;
 }>): import("react").ReactNode;

package/dist/types/{component → luna-react/src/component}/input/input-common.d.ts

@@ -1,2 +1,2 @@
-import type { CommonProps, Field } from '../../type';
+import { type CommonProps, type Field } from '@luna-form/core';
 export declare function buildCommon(field: Field, disabled?: boolean): CommonProps;

package/dist/types/{component → luna-react/src/component}/input/input-option-select.d.ts

@@ -1,4 +1,4 @@
-import type { Field } from '../../type';
+import { type Field } from '@luna-form/core';
 export declare function buildOptionSelect(field: Field): {
     value: string;
     label: string;

package/dist/types/luna-react/src/component/input-group.d.ts

@@ -0,0 +1,5 @@
+import { type Field } from '@luna-form/core';
+export declare function InputGroup(props: Readonly<{
+    children: React.ReactNode;
+    field: Field;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/component/input-label.d.ts

@@ -0,0 +1,5 @@
+import { type Field, type Orientation } from '@luna-form/core';
+export declare function InputLabel(props: Readonly<{
+    field: Field;
+    orientation: Orientation;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component}/label.d.ts

@@ -1,5 +1,5 @@
+import { type Field } from '@luna-form/core';
 export declare function Label(props: Readonly<{
     children?: React.ReactNode;
-    name: string;
-    required?: boolean;
+    field: Field;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/types/{component → luna-react/src/component}/slot/slot-base.d.ts

@@ -1,6 +1,7 @@
-import type { Children, Fields } from '../../type';
+import { type Fields } from '@luna-form/core';
+import type { Children } from '../../type';
 import type { ColumnProps } from '../column';
-import type { FieldProps } from '../field';
+import type { FieldProps } from '../field/field';
 export declare function SlotBase<T extends {
     column: React.ComponentType<ColumnProps>;
     field: React.ComponentType<FieldProps>;
@@ -8,6 +9,5 @@ export declare function SlotBase<T extends {
     children: Children;
     disabled?: boolean;
     fields?: Fields;
-    withinColumn?: boolean;
     components: T;
 }>): import("react/jsx-runtime").JSX.Element[];

package/dist/types/{client/component → luna-react/src/component/slot}/slot.d.ts

@@ -1,7 +1,7 @@
-import type { Children, Fields } from '../../type';
+import type { Children } from '../../type';
+import type { Fields } from '@luna-form/core';
 export declare const Slot: (props: Readonly<{
     children: Children;
     disabled?: boolean;
     fields?: Fields;
-    withinColumn?: boolean;
 }>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/luna-react/src/config/index.d.ts

@@ -0,0 +1,28 @@
+import { type Environment, type Orientation, type Protocol } from '@luna-form/core';
+import type { Config, InputConfig } from '../type';
+export declare function defineConfig<T extends React.ElementType>(options: Readonly<{
+    env?: Environment;
+    fetcher?: {
+        remotePatterns?: Array<{
+            hostname?: string;
+            port?: number;
+            protocol?: Protocol;
+        }>;
+    };
+    inputs: Array<InputConfig<T>>;
+    style?: {
+        compact?: boolean;
+        orientation?: Orientation;
+    };
+    validation?: {
+        blur?: boolean;
+        change?: boolean;
+        submit?: boolean;
+    };
+}>): Config;
+export declare const defineCheckbox: (input: any) => InputConfig<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>;
+export declare const defineInput: (input: any) => InputConfig<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>;
+export declare const defineRadio: (input: any) => InputConfig<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>;
+export declare const defineSelect: (input: any) => InputConfig<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>;
+export declare const defineTextArea: (input: any) => InputConfig<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>;
+export declare function defineCustomInput<T extends React.ElementType>(types: string | string[], input: React.ComponentProps<T>): InputConfig<T>;

package/dist/types/luna-react/src/lib/render-If-exists.d.ts

@@ -0,0 +1 @@
+export declare function renderIfExists<T>(value: T | undefined | null, render: (value: T) => React.ReactNode): React.ReactNode;

package/dist/types/luna-react/src/lib/string.d.ts

@@ -0,0 +1 @@
+export declare function formatMarkdown(text?: string): React.ReactNode;

package/dist/types/{server → luna-react/src/server}/component/fallback.d.ts

@@ -1,4 +1,5 @@
-import type { Config, Sections } from '../../type';
+import type { Config } from '../../type';
+import type { Sections } from '@luna-form/core';
 export declare function Fallback(props: Readonly<{
     children: React.ReactNode;
     config: Config;

package/dist/types/{client → luna-react/src/server}/component/form.d.ts

@@ -1,8 +1,9 @@
-import type { Sections, Config, Source } from '../../type';
+import type { Config } from '../../type';
+import type { Definition, Sections, Source } from '@luna-form/core';
 export declare function Form(props: Readonly<{
-    action?: (formData: FormData) => Promise<void> | void;
     children?: React.ReactNode;
     config: Config;
+    definition?: Definition;
     readOnly?: boolean;
     sections: Sections;
     source?: Source;

package/dist/types/{server → luna-react/src/server}/component/input.d.ts

@@ -1,4 +1,5 @@
-import type { AriaAttributes, CommonProps, DataAttributes, Field, Config, Source } from '../../type';
+import { type AriaAttributes, type CommonProps, type DataAttributes, type Field, type Source } from '@luna-form/core';
+import type { Config } from '../../type';
 export declare function Input(props: Readonly<{
     ariaAttributes?: AriaAttributes;
     commonProps: CommonProps;
@@ -7,4 +8,4 @@ export declare function Input(props: Readonly<{
     field: Field;
     source?: Source;
     value?: Record<string, unknown>;
-}>): import("react/jsx-runtime").JSX.Element | null;
+}>): import("react").ReactNode;

package/dist/types/{server → luna-react/src/server}/index.d.ts

@@ -1,4 +1,4 @@
 import { Form } from './component/form';
 import { Fallback } from './component/fallback';
 export { Form, Fallback };
-export type { Sections, Source } from '../type';
+export type { Sections, Source } from '@luna-form/core';

package/dist/types/luna-react/src/type.d.ts

@@ -0,0 +1,16 @@
+import type { AriaAttributes, CommonProps, DataAttributes, Field, Fields, BaseConfig } from '@luna-form/core';
+export type Slot = (props: {
+    disabled?: boolean;
+    fields?: Fields;
+}) => React.ReactNode;
+export type Children = (props: {
+    ariaAttributes?: AriaAttributes;
+    commonProps: CommonProps;
+    dataAttributes?: DataAttributes;
+    field: Field;
+}) => React.ReactNode;
+export type InputConfig<T extends React.ElementType> = {
+    types: string | string[];
+    input: React.ComponentProps<T>;
+};
+export type Config = BaseConfig<React.ComponentProps<React.ElementType>>;