react-luna-form 0.0.71 → 0.0.73

package/dist/types/luna-core/type.d.ts

@@ -0,0 +1,267 @@
+import type { core, z, ZodObject } from 'zod';
+export type Schema = z.ZodTypeAny;
+export type Schemas = Record<string, Schema>;
+export type ZodSchema = ZodObject<{
+    [x: string]: Schema;
+}, core.$strip>;
+export type Nullable<T> = T | null;
+export type DataAttributes = Record<string, string | number | boolean>;
+export type AriaAttributes = Record<string, string | number | boolean>;
+export type Description = string | {
+    collapsed?: boolean;
+    message: string;
+    title: string;
+};
+export type TimeFormat = 'HH:mm' | 'HH:mm:ss' | 'hh:mm a' | 'hh:mm:ss a';
+export type DateFormat = 'yyyy-MM-dd' | 'MM/dd/yyyy' | 'dd/MM/yyyy' | 'MMMM d, yyyy';
+export type DataSource = {
+    body?: BodyInit | Record<string, unknown>;
+    cache?: RequestCache;
+    headers?: HeadersInit;
+    method?: string;
+    namespace?: string;
+    url: string;
+};
+export type Source = {
+    [key: string]: DataSource | Array<unknown>;
+};
+export type Definition = Record<string, unknown>;
+export type Orderable = {
+    order?: number;
+};
+export type Hideable = {
+    hidden?: boolean;
+};
+export type Sections = Section[];
+export type Multiple = readonly (string | number | boolean)[];
+export type Value = string | number | boolean | Multiple;
+export type Option = {
+    description?: string;
+    label: string;
+    value: string;
+};
+export type OptionGroup = {
+    items: Option[];
+    label: string;
+};
+export type PreviewItem = string | {
+    field?: string;
+    label?: string;
+    when?: string | string[] | Condition;
+};
+export type List = {
+    advanced?: {
+        title?: string;
+        action?: string;
+        collapsed?: boolean;
+        length?: Length<number>;
+        preview?: {
+            label?: PreviewItem;
+            tags?: PreviewItem[];
+            badge?: PreviewItem;
+        };
+    };
+    description?: string;
+    fields: Array<AnyField | Column>;
+    label?: string;
+    name: string;
+    type: 'list' | (string & {});
+    validation?: {
+        length?: Length<string>;
+    };
+} & Base;
+export type AnyField = Field | Input | Select | Chips | Date | Time;
+export type Fields = Array<AnyField | Column | List>;
+export type Base = Orderable & Hideable;
+export type CommonProps = {
+    disabled?: boolean;
+    id?: string;
+    name?: string;
+    placeholder?: string;
+    required?: boolean;
+};
+export type Section = {
+    advanced?: {
+        collapsible?: boolean;
+        compact?: boolean;
+        separator?: boolean;
+    };
+    description?: string;
+    fields?: Fields;
+    id?: string | number;
+    title?: string;
+} & Base;
+export type Column = {
+    advanced?: {
+        cols?: number;
+    };
+    description?: Description;
+    fields: Array<AnyField>;
+    type: 'column' | (string & {});
+} & Base;
+export type Operator = 'eq' | 'neq' | 'in' | 'nin' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'exists' | 'empty' | 'truthy';
+export type Condition = {
+    field?: string;
+    operator?: Operator;
+    value: string | number | string[];
+};
+export type CustomValidation = {
+    field: string;
+    message?: string;
+    operator?: Operator;
+};
+export type FieldState = {
+    description?: Description;
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type ActionEvent<T> = {
+    action: T;
+};
+export type SourceEvent = ActionEvent<'source'> & {
+    source: DataSource;
+    target: string;
+};
+export type ValueEvent = ActionEvent<'value'> & {
+    onlyIfTargetEmpty?: boolean;
+    value: Record<string, Value | Array<Record<string, unknown>>>;
+};
+export type StateEvent = ActionEvent<'state'> & {
+    state: FieldState;
+    target: string | string[];
+    when?: string | string[] | Condition;
+};
+export type ChangeEvent = Array<SourceEvent | ValueEvent | StateEvent>;
+export type WhenRule = {
+    field: string;
+    operator?: Operator;
+    value?: string | number | boolean | Array<string | number>;
+    message?: string;
+};
+export type PatternRule = {
+    regex: string;
+    flags?: string;
+    message?: string;
+    allowInterpolation?: boolean;
+};
+export type WhenClause = WhenRule | WhenRule[] | {
+    all?: WhenRule[];
+    any?: WhenRule[];
+};
+export type AssertRule = {
+    when?: WhenClause;
+    assert: 'required' | 'minItems' | 'maxItems' | 'pattern' | 'oneOf' | 'min' | 'max';
+    value?: string | number | Array<string | number> | PatternRule;
+    message: string;
+};
+export type Validation = {
+    custom?: CustomValidation | Array<CustomValidation>;
+    email?: string;
+    length?: Length<string>;
+    required?: string;
+    requiredWhen?: WhenRule | Array<WhenRule>;
+    pattern?: PatternRule;
+    rules?: Array<AssertRule>;
+};
+export type Field = CommonProps & {
+    advanced?: {
+        aria?: AriaAttributes;
+        autocomplete?: string;
+        cols?: number;
+        data?: DataAttributes;
+        entity?: string;
+        horizontal?: boolean;
+        reverse?: boolean;
+    };
+    defaultValue?: Value;
+    event?: {
+        change?: ChangeEvent;
+    };
+    description?: Description;
+    fields?: never;
+    label?: string;
+    name: string;
+    readonly?: boolean;
+    type: string;
+    validation?: Validation;
+} & Base;
+export type Length<T> = {
+    max?: T;
+    min?: T;
+};
+export type Transform = 'lowercase' | 'uppercase' | 'remove-space' | 'remove-accent';
+export type Input = Field & {
+    advanced?: {
+        length?: Length<number>;
+        transform?: Transform | Transform[];
+    };
+};
+export type Select = Field & {
+    advanced?: {
+        autocomplete?: never;
+        length?: Length<number | string>;
+        options?: Option;
+        preselected?: boolean;
+    };
+    source?: DataSource | Array<unknown>;
+};
+export type Chips = Select & {
+    advanced?: {
+        multiple?: boolean;
+    };
+};
+type TemporalField<T> = Field & {
+    advanced?: {
+        format?: T;
+    };
+};
+export type Date = TemporalField<DateFormat>;
+export type Time = TemporalField<TimeFormat>;
+export type Environment = {
+    [key: string]: Value;
+};
+export type Protocol = 'http' | 'https';
+export type RemotePattern = {
+    hostname?: string;
+    port?: number;
+    protocol?: Protocol;
+};
+export type FormStateError = {
+    description?: string;
+    details?: Nullable<Record<string, string[]> | string[]>;
+    title: string;
+};
+export type BaseConfig<T> = {
+    env?: Environment;
+    fetcher: {
+        provider: <T>(dataSource: DataSource) => Promise<T>;
+        remotePatterns?: Array<RemotePattern>;
+    };
+    inputs: {
+        [key: string]: T;
+    };
+    style?: Style;
+    validation: {
+        blur?: boolean;
+        change?: boolean;
+        showError?: boolean;
+        submit?: boolean;
+    };
+};
+export type Style = {
+    compact?: boolean;
+    horizontal?: boolean;
+    showOptionalLabel?: boolean;
+};
+export type Filterable = Base & {
+    fields?: Filterable[];
+};
+export type TimezoneItem = {
+    label: string;
+    value: string;
+};
+export type TimezoneGroup = {
+    items: TimezoneItem[];
+    label: string;
+};
+export {};

package/dist/types/luna-core/util/attributes.d.ts

@@ -0,0 +1,6 @@
+import type { Field } from '../type';
+export declare function getPrefixedAttributes(prefix: string, record?: Record<string, string | number | boolean>): Record<string, string | number | boolean>;
+export declare function getAriaAttributes(record?: Record<string, string | number | boolean>): Record<string, string | number | boolean>;
+export declare function getDataAttributes(record?: Record<string, string | number | boolean>): Record<string, string | number | boolean>;
+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/luna-core/util/build.d.ts

@@ -0,0 +1,6 @@
+import type { Field, Nullable } from '../type';
+export declare function buildOptions(field: Field, values?: Nullable<Record<string, unknown>>): Record<string, unknown>[] | undefined;
+export declare function buildOrientation(field: Field): boolean;
+export declare function buildReverse(field: Field): boolean;
+export declare function buildDisabled(field: Field, disabled?: boolean): boolean;
+export declare function buildSource(field: Field): import("..").DataSource | unknown[] | undefined;

package/dist/types/luna-core/util/column.d.ts

@@ -0,0 +1,2 @@
+export declare function getColumn(value?: number, defaultCols?: number): string;
+export declare function getSpan(value?: number): string | undefined;

package/dist/types/luna-core/util/condition.d.ts

@@ -0,0 +1,2 @@
+import type { Condition } from '../type';
+export declare function evaluateCondition<T>(selected: T, when?: string | string[] | boolean | Condition): boolean;

package/dist/types/luna-core/util/constant.d.ts

@@ -0,0 +1,53 @@
+export declare const INPUT = "input";
+export declare const INPUT_DATE = "input/date";
+export declare const INPUT_EMAIL = "input/email";
+export declare const INPUT_NUMBER = "input/number";
+export declare const INPUT_PASSWORD = "input/password";
+export declare const INPUT_TEL = "input/tel";
+export declare const INPUT_TEXT = "input/text";
+export declare const INPUT_TIME = "input/time";
+export declare const INPUTS: string[];
+export declare const TEXTAREA = "textarea";
+export declare const RADIO = "radio";
+export declare const CHECKBOX = "checkbox";
+export declare const LIST = "list";
+export declare const DATA_TABLE = "data-table";
+export declare const SELECT = "select";
+export declare const SELECT_ACTIVE = "select/active";
+export declare const SELECT_DAY = "select/day";
+export declare const SELECT_MONTH = "select/month";
+export declare const SELECT_TIMEZONE = "select/timezone";
+export declare const SELECT_YEAR = "select/year";
+export declare const SELECTS: string[];
+export declare const CHIPS = "chips";
+export declare const CHIPS_DAYS = "chips/day";
+export declare const CHIPS_MONTHS = "chips/month";
+export declare const COLUMN = "column";
+export declare const DESCRIPTION = "description";
+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";
+export declare const TYPE_TEL = "tel";
+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 MAX = "max";
+export declare const MAX_LENGTH = "maxLength";
+export declare const MIN = "min";
+export declare const MIN_LENGTH = "minLength";
+export declare const $REF = "$ref";
+export declare const SET = "set";
+export declare const SOURCE = "source";
+export declare const STATE = "state";
+export declare const COMMON_URL = "http://luna.internal";
+export declare const HIDDEN = "hidden";
+export declare const TYPE = "type";
+export declare const TIMEZONE_REGIONS: Record<string, string>;

package/dist/types/luna-core/util/date.d.ts

@@ -0,0 +1,23 @@
+import type { Date as DateField, DateFormat, Time, TimeFormat, TimezoneGroup } from '../type';
+export declare function getMonth(): {
+    value: string;
+    label: string;
+}[];
+export declare function getWeekDays(): {
+    value: string;
+    label: string;
+}[];
+export declare function getYear(min: number, max: number): Array<{
+    value: string;
+    label: string;
+}>;
+export declare function getCurrentYear(): number;
+export declare function getUserTimezone(): string;
+export declare function getTimezones(): TimezoneGroup[];
+export declare function getConvert(value: string | number, current?: number): number;
+export declare function toNativeDate(value: string, fromFormat: DateFormat): string;
+export declare function toNativeTime(value: string, fromFormat: TimeFormat): string;
+export declare function fromNativeTime(native: string, toFormat?: TimeFormat): string;
+export declare function fromNativeDate(native: string, toFormat?: DateFormat): string;
+export declare function getTimeFormat(field: Time): TimeFormat;
+export declare function getDateFormat(field: DateField): DateFormat;

package/dist/types/luna-core/util/extract.d.ts

@@ -0,0 +1,16 @@
+import type { Nullable, Option, Value } from '../type';
+export declare function getEntity<T>(selected: string, collection?: Nullable<T[]>, entity?: string): NonNullable<T> | {
+    value: string;
+};
+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 | {
+    description?: string | undefined;
+    label: string;
+    value: string;
+})[];
+export declare function getType(value?: string): string;
+export declare function getFormData(formData: FormData): Record<string, unknown>;
+export declare function unflatten(data: Record<string, unknown>): Record<string, unknown>;

package/dist/types/luna-core/util/format.d.ts

@@ -0,0 +1,6 @@
+export type FormatContext = {
+    locale?: string;
+};
+export type FormatFilter = (value: unknown, args: string[], ctx: FormatContext) => string;
+export declare const formatFilters: Record<string, FormatFilter>;
+export declare function applyFormatFilter(value: unknown, expression: string, ctx: FormatContext): string | undefined;

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

@@ -0,0 +1,26 @@
+import type { Chips, Column, Field, Input, List, Nullable, Select, Time } from '../type';
+export declare const isSelectActive: (field: Field) => boolean;
+export declare const isSelectDay: (field: Field) => boolean;
+export declare const isSelectMonth: (field: Field) => boolean;
+export declare const isSelectYear: (field: Field) => boolean;
+export declare const isSelectTimezone: (field: Field) => boolean;
+export declare const isChipsDays: (field: Field) => boolean;
+export declare const isChipsMonths: (field: Field) => boolean;
+export declare const isDate: (field: Field) => field is Field;
+export declare const isTime: (field: Field) => field is Time;
+export declare const isCheckbox: (field: Field) => field is Input;
+export declare const isChips: (field: Field) => field is Chips;
+export declare const isRadio: (field: Field) => field is Select;
+export declare const isInput: (field: Field) => field is Input;
+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 isList(slot: Field | Column | List): slot is List;
+export declare function isColumn(slot: Field | Column | List): slot is Column;
+export declare function isField(slot: Field | Column | List): slot is Field;
+export declare function isOptions(field: Field): field is Select;
+export declare function isTextable(field: Field): boolean;
+export declare function isValidValue<T>(value?: Nullable<T>): boolean;

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

@@ -0,0 +1,7 @@
+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;
+export declare function isBoolean(value: unknown): value is boolean;

package/dist/types/luna-core/util/list.d.ts

@@ -0,0 +1,5 @@
+import type { Column, Field, List, Nullable } from '../type';
+export declare function isMultiFieldList(list: List): boolean;
+export declare function getInitialList(list: List, value?: Nullable<Record<string, unknown>>): number[];
+export declare function getLabel(list: List): string;
+export declare function flattenListFields(fields: Array<Field | Column>): Record<string, Field>;

package/dist/types/luna-core/util/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+};

package/dist/types/luna-core/util/operator.d.ts

@@ -0,0 +1 @@
+export declare const operators: Record<string, (current: unknown, value: unknown) => boolean>;

package/dist/types/luna-core/util/path.d.ts

@@ -0,0 +1 @@
+export declare function resolveTarget(target: string, name: string): string;

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

@@ -0,0 +1,4 @@
+import type { Definition, Filterable, Nullable } from '../type';
+export declare function prepare<T extends Filterable>(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/util/schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { CustomValidation, Definition, Field, Input, Schemas, Sections, ZodSchema } from '../type';
+export declare function buildSchema(schemas: Schemas, fields?: Field[], translations?: Record<string, string>): ZodSchema;
+export declare function flatten(error: z.ZodError<Record<string, unknown>>): Record<string, string[]>;
+export declare function getSchema(input: Input, translations?: Record<string, string>): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+export declare function getEmail(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodPipe<z.ZodString, z.ZodEmail>> | z.ZodNullable<z.ZodUnion<[z.ZodPipe<z.ZodString, z.ZodEmail>, z.ZodLiteral<"">]>>;
+export declare function getBoolean(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodPreprocess<z.ZodCoercedBoolean<unknown>>> | z.ZodNullable<z.ZodPreprocess<z.ZodCoercedBoolean<unknown>>>;
+export declare function getRadio(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodCoercedString<unknown>> | z.ZodNullable<z.ZodUnion<[z.ZodCoercedString<unknown>, z.ZodLiteral<"">]>>;
+export declare function getText(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodCoercedString<unknown>> | z.ZodNullable<z.ZodCoercedString<unknown>>;
+export declare function getNumber(input: Input, translations?: Record<string, string>): z.ZodNullable<z.ZodCoercedNumber<unknown>> | z.ZodPreprocess<z.ZodCoercedNumber<unknown>>;
+export declare function getYearSchema(input: Input, translations?: Record<string, string>): z.ZodNullable<z.ZodCoercedNumber<unknown>> | z.ZodPreprocess<z.ZodCoercedNumber<unknown>>;
+export declare function getMonthSchema(input: Input, translations?: Record<string, string>): z.ZodCoercedNumber<unknown> | z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+export declare function applyCustomValidation(schema: ZodSchema, fields?: Field[], translations?: Record<string, string>): ZodSchema;
+export declare function validateCustom(value: unknown, rules: CustomValidation | Array<CustomValidation>, getValue: (name: string) => unknown, translations?: Record<string, string>): string[];
+export declare function getArraySchema(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodArray<z.ZodString>>;
+export declare function buildFormSchema(sections: Sections, translations?: Record<string, string>, definition?: Definition): z.ZodType;
+export declare function collectIssues(error: z.ZodError): Array<{
+    path: string;
+    message: string;
+}>;
+export declare function applyDeclarativeRules<T extends z.ZodType>(schema: T, fields?: Field[], translations?: Record<string, string>): T;

package/dist/types/luna-core/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/util/string.d.ts

@@ -0,0 +1,12 @@
+export type InterpolateOptions = {
+    locale?: string;
+};
+/**
+ * Replaces placeholders in the format {key} with values from the provided object.
+ * Supports nested objects using dot notation (e.g., {user.id}) and pipe filters
+ * (e.g., {price | currency:USD}).
+ */
+export declare function interpolate<T>(template: T, values?: Record<string, unknown>, options?: InterpolateOptions): T;
+export declare function interpolateIfNeeded<T>(template: T, values?: Record<string, unknown>, options?: InterpolateOptions): 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/util/stringify.d.ts

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

package/dist/types/luna-core/util/style.d.ts

@@ -0,0 +1,6 @@
+import type { Style } from '../type';
+export declare function mergeStyle(globalStyle?: Style, localStyle?: Style): {
+    compact?: boolean;
+    horizontal?: boolean;
+    showOptionalLabel?: boolean;
+};

package/dist/types/luna-core/util/transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from '../type';
+export declare function applyTransform(value: unknown, transform?: Transform | Transform[]): unknown;

package/dist/types/luna-core/util/translate.d.ts

@@ -0,0 +1 @@
+export declare function translate(key?: string, dictionary?: Record<string, string>): string;

package/dist/types/luna-core/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/field/field-list-preview-item.d.ts

@@ -1,4 +1,4 @@
-import type { List, Nullable, PreviewItem } from '@luna-form/core';
+import type { List, Nullable, PreviewItem } from '../../../../../luna-core/index';
 import type { ReactNode } from 'react';
 export declare function FieldListPreviewItem({ canRemove, children, field, index, isMultiField, itemKey, label, onRemove, previewBadge, previewLabel, previewTags, translations, value, }: {
     canRemove: boolean;

package/dist/types/luna-react/src/client/component/field/field-preview-item.d.ts

@@ -1,4 +1,4 @@
-import { type Option } from '@luna-form/core';
+import { type Option } from '../../../../../luna-core/index';
 export declare function FieldPreviewItem({ className, initialValue, name, options, separator, staticLabel, }: Readonly<{
     className?: string;
     initialValue?: unknown;

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

@@ -1,4 +1,4 @@
-import type { Column, Field, PreviewItem } from '@luna-form/core';
+import type { Column, Field, PreviewItem } from '../../../../../luna-core/index';
 export declare function FieldPreview({ className, fields, label, name, previews, translations, value, }: Readonly<{
     className?: string;
     fields?: Array<Field | Column>;

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

@@ -2,6 +2,6 @@ export declare const Field: (props: Readonly<Readonly<Readonly<{
     children: import("../../../type").Children;
     disabled?: boolean;
     errors?: Record<string, string[]>;
-    field: import("@luna-form/core").Field;
-    style?: import("@luna-form/core").Style;
+    field: import('../../../../../luna-core/index').Field;
+    style?: import('../../../../../luna-core/index').Style;
 }>>>) => import("react").JSX.Element | null;

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

@@ -1,6 +1,6 @@
 import { type FormState } from '../hook/use-form-action';
 import type { Config, Control } from '../../type';
-import type { Definition, Nullable, Sections, ZodSchema } from '@luna-form/core';
+import type { Definition, Nullable, Sections, ZodSchema } from '../../../../luna-core/index';
 export declare function FormContent<T extends Record<string, unknown> = Record<string, unknown>, F = Record<string, unknown>>(props: Readonly<{
     advanced?: {
         step?: boolean;

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

@@ -1,5 +1,5 @@
 import type { Config, Control } from '../../type';
-import type { Definition, Nullable, Sections, ZodSchema } from '@luna-form/core';
+import type { Definition, Nullable, Sections, ZodSchema } from '../../../../luna-core/index';
 import type { FormState } from '../hook/use-form-action';
 export declare function Form<T extends Record<string, unknown> = Record<string, unknown>, F = Record<string, unknown>>(props: Readonly<{
     advanced?: {

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

@@ -1,4 +1,4 @@
-import type { Field, Fields, List } from '@luna-form/core';
+import type { Field, Fields, List } from '../../../../../luna-core/index';
 export declare function VisibilityGuard(props: Readonly<{
     children: React.ReactNode;
     container?: Field | List;

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

@@ -1,3 +1,3 @@
-import type { Field } from '@luna-form/core';
+import type { Field } from '../../../../luna-core/index';
 export declare function isEmptySelectChange(field: Field, inputValue: string): boolean;
 export declare const InputSelectable: (props: import("../hook/use-input-core").InputCoreProps) => import("react").JSX.Element;

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

@@ -1,5 +1,5 @@
 import type { Config } from '../../type';
-import type { DataSource, Field, Nullable } from '@luna-form/core';
+import type { DataSource, Field, Nullable } from '../../../../luna-core/index';
 export type InputStrategies = Readonly<{
     useSource: (field: Field, config: Config, value?: Nullable<Record<string, unknown>>) => {
         data: Nullable<unknown[]>;

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

@@ -3,12 +3,12 @@ export declare const Slot: (props: Readonly<{
     config: import("../../../type").Config;
     context?: Record<string, unknown>;
     disabled?: boolean;
-    fields?: import("@luna-form/core").Fields;
+    fields?: import('../../../../../luna-core/index').Fields;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
-    style?: import("@luna-form/core").Style;
+    style?: import('../../../../../luna-core/index').Style;
     translations?: Record<string, string>;
-    value?: import("@luna-form/core").Nullable<Record<string, unknown>>;
+    value?: import('../../../../../luna-core/index').Nullable<Record<string, unknown>>;
 }>) => import("react").JSX.Element;

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

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

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

@@ -1,3 +1,3 @@
-import { type DataSource, type Nullable } from '@luna-form/core';
+import { type DataSource, type Nullable } from '../../../../luna-core/index';
 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-field-list.d.ts

@@ -1,4 +1,4 @@
-import { type List, type Nullable } from '@luna-form/core';
+import { type List, type Nullable } from '../../../../luna-core/index';
 import { type TranslateListPath } from '../context/list-path-context';
 export declare function useFieldList(field: List, value?: Nullable<Record<string, unknown>>, onValueChange?: (input: {
     name: string;