@evanschleret/formforgeclient 1.0.0

package/dist/runtime/renderers/default/FormForgeResponse.vue.d.ts

@@ -0,0 +1,18 @@
+import type { FormForgeClientConfig } from '../../types/index.js';
+type FormForgeResponseLayout = 'line' | 'column';
+interface Props {
+    responseUuid: string;
+    formKey?: string;
+    endpoint?: string;
+    layout?: FormForgeResponseLayout;
+    clientConfig?: FormForgeClientConfig;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    endpoint: string;
+    clientConfig: FormForgeClientConfig;
+    layout: FormForgeResponseLayout;
+    formKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;
+//# sourceMappingURL=FormForgeResponse.vue.d.ts.map

package/dist/runtime/renderers/default/index.d.ts

@@ -0,0 +1,5 @@
+export { default as FormForgeRenderer } from './FormForgeRenderer.vue.js';
+export { default as FormForgeBuilder } from './FormForgeBuilder.vue.js';
+export { default as FormForgeResponse } from './FormForgeResponse.vue.js';
+export { default as FormForgeCategoryCreateModal } from './FormForgeCategoryCreateModal.vue.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/renderers/default/index.js

@@ -0,0 +1,4 @@
+export { default as FormForgeRenderer } from "./FormForgeRenderer.vue";
+export { default as FormForgeBuilder } from "./FormForgeBuilder.vue";
+export { default as FormForgeResponse } from "./FormForgeResponse.vue";
+export { default as FormForgeCategoryCreateModal } from "./FormForgeCategoryCreateModal.vue";

package/dist/runtime/renderers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './default/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/renderers/index.js

@@ -0,0 +1 @@
+export * from "./default/index.js";

package/dist/runtime/types/api.d.ts

@@ -0,0 +1,129 @@
+import type { FormForgeJsonObject } from './json.js';
+export type FormForgeUploadMode = 'managed' | 'direct' | 'staged';
+export type FormForgeDatetimeMode = 'offset' | 'utc';
+export interface FormForgeResolvedScope {
+    prefix: string;
+    params: Record<string, string | number>;
+}
+export interface FormForgeScopedRouteDefinition {
+    prefix: string;
+    paramsFromRoute: Record<string, string>;
+}
+export type FormForgeScopedRouteMap = Record<string, FormForgeScopedRouteDefinition>;
+export type FormForgeScope = string | FormForgeResolvedScope;
+export type FormForgeScopeParams = Record<string, string | number | undefined>;
+export type FormForgeScopeParamsInput = FormForgeScopeParams | (() => FormForgeScopeParams);
+export interface FormForgeRangeValue {
+    start: string | null;
+    end: string | null;
+}
+export interface FormForgeStagedUploadValue {
+    upload_token: string;
+}
+export interface FormForgeDirectUploadValue {
+    disk: string;
+    path: string;
+    original_name?: string;
+}
+export type FormForgeSubmissionScalarValue = string | number | boolean | null;
+export interface FormForgeJsonSubmissionObject {
+    [key: string]: FormForgeJsonSubmissionValue;
+}
+export type FormForgeJsonSubmissionValue = FormForgeSubmissionScalarValue | FormForgeRangeValue | FormForgeStagedUploadValue | FormForgeDirectUploadValue | FormForgeJsonSubmissionObject | FormForgeJsonSubmissionValue[];
+export type FormForgeSubmissionValue = FormForgeJsonSubmissionValue | File | File[];
+export interface FormForgeSubmissionPayload {
+    [key: string]: FormForgeSubmissionValue;
+}
+export interface FormForgeJsonSubmissionPayload {
+    [key: string]: FormForgeJsonSubmissionValue;
+}
+export interface FormForgeSubmitInput {
+    payload: FormForgeJsonSubmissionPayload;
+    meta?: FormForgeJsonObject;
+    test?: boolean;
+}
+export interface FormForgeSubmissionResponse {
+    data: FormForgeJsonObject;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeResponsesListResponse {
+    data: FormForgeJsonObject[];
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeSchemaVersionsResponse {
+    data: FormForgeJsonObject;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeStageUploadInput {
+    field?: string;
+    field_key?: string;
+    file: File;
+}
+export interface FormForgeStagedUploadResponse {
+    data: {
+        staged: {
+            upload_token: string;
+            expires_at?: string;
+        };
+    };
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeResolveInput {
+    payload?: FormForgeJsonSubmissionPayload;
+    debug?: boolean;
+}
+export interface FormForgeDraftSaveInput {
+    payload: FormForgeJsonSubmissionPayload;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeDraftRecord {
+    form_key: string;
+    form_version?: string;
+    owner_type?: string;
+    owner_id?: string | number | null;
+    payload: FormForgeJsonSubmissionPayload;
+    meta?: FormForgeJsonObject;
+    expires_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface FormForgeDraftResponse {
+    data: FormForgeDraftRecord | null;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeHttpRequest {
+    path: string;
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean | undefined>;
+    json?: FormForgeJsonObject;
+    body?: BodyInit;
+}
+export interface FormForgeHttpResponse<TData> {
+    status: number;
+    headers: Headers;
+    data: TData;
+}
+export type FormForgeHttpAdapter = <TData>(request: FormForgeHttpRequest) => Promise<FormForgeHttpResponse<TData>>;
+export interface FormForgeBeforeRequestContext {
+    request: FormForgeHttpRequest;
+    headers: Record<string, string>;
+    url?: string;
+}
+export type FormForgeBaseURLParams = Record<string, string | number | undefined>;
+export type FormForgeBaseURLParamsInput = FormForgeBaseURLParams | (() => FormForgeBaseURLParams);
+export interface FormForgeClientConfig {
+    baseURL?: string;
+    baseURLParams?: FormForgeBaseURLParamsInput;
+    scopedRoutes?: FormForgeScopedRouteMap;
+    defaultScope?: string;
+    scopeParams?: FormForgeScopeParamsInput;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+    beforeRequest?: (context: FormForgeBeforeRequestContext) => Promise<void> | void;
+    uploadMode?: FormForgeUploadMode;
+    datetimeMode?: FormForgeDatetimeMode;
+    locale?: string;
+}
+//# sourceMappingURL=api.d.ts.map

package/dist/runtime/types/category.d.ts

@@ -0,0 +1,42 @@
+import type { FormForgeJsonObject } from './json.js';
+export interface FormForgeCategory {
+    id: number;
+    key: string;
+    name: string;
+    description: string | null;
+    is_active: boolean;
+    meta: FormForgeJsonObject;
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface FormForgeCategoryCreateInput {
+    key?: string;
+    name: string;
+    description?: string | null;
+    is_active?: boolean;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeCategoryUpdateInput {
+    name?: string;
+    description?: string | null;
+    is_active?: boolean;
+    meta?: FormForgeJsonObject;
+}
+export interface FormForgeCategoryListQuery {
+    per_page?: number;
+    search?: string;
+    is_active?: boolean;
+}
+export type FormForgePaginationLinks = FormForgeJsonObject;
+export type FormForgePaginationMeta = FormForgeJsonObject;
+export interface FormForgeCategoryListResponse {
+    data: FormForgeCategory[];
+    meta?: FormForgePaginationMeta;
+    links?: FormForgePaginationLinks;
+}
+export interface FormForgeCategorySelectOption {
+    label: string;
+    value: string;
+    disabled: boolean;
+}
+//# sourceMappingURL=category.d.ts.map

package/dist/runtime/types/errors.d.ts

@@ -0,0 +1,16 @@
+import type { FormForgeJsonObject } from './json.js';
+export type FormForgeClientErrorCode = 'unauthorized' | 'forbidden' | 'not_found' | 'conflict' | 'validation' | 'rate_limited' | 'server_error' | 'network_error';
+export type FormForgeBusinessErrorCode = 'CATEGORY_IN_USE';
+export interface FormForgeClientError {
+    status: number;
+    code: FormForgeClientErrorCode;
+    message: string;
+    businessCode?: FormForgeBusinessErrorCode;
+    fieldErrors?: Record<string, string[]>;
+    raw?: FormForgeJsonObject | null;
+}
+export interface FormForgeValidationErrorPayload {
+    message?: string;
+    errors?: Record<string, string[]>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,8 @@
+export type { FormForgeClientError, FormForgeClientErrorCode, FormForgeBusinessErrorCode, FormForgeValidationErrorPayload } from './errors.js';
+export type { FormForgeCategory, FormForgeCategoryCreateInput, FormForgeCategoryUpdateInput, FormForgeCategoryListQuery, FormForgeCategoryListResponse, FormForgePaginationMeta, FormForgePaginationLinks, FormForgeCategorySelectOption } from './category.js';
+export type { FormForgeFieldType, FormForgeFieldOption, FormForgeFieldOptionObject, FormForgeFieldSchema, FormForgeFileFieldSchema, FormForgePageSchema, FormForgeCondition, FormForgeConditionClause, FormForgeConditionAction, FormForgeConditionMatch, FormForgeConditionOperator, FormForgeConditionTargetType, FormForgeDraftSettings, FormForgeFormSchema, FormForgeOptionValue, FormForgeFieldStorage } from './schema.js';
+export type { FormForgeBeforeRequestContext, FormForgeBaseURLParams, FormForgeBaseURLParamsInput, FormForgeClientConfig, FormForgeDraftRecord, FormForgeDraftResponse, FormForgeDraftSaveInput, FormForgeHttpAdapter, FormForgeHttpRequest, FormForgeHttpResponse, FormForgeResolveInput, FormForgeSchemaVersionsResponse, FormForgeScopedRouteDefinition, FormForgeScopedRouteMap, FormForgeScope, FormForgeScopeParams, FormForgeScopeParamsInput, FormForgeResolvedScope, FormForgeStageUploadInput, FormForgeStagedUploadResponse, FormForgeSubmitInput, FormForgeJsonSubmissionPayload, FormForgeJsonSubmissionObject, FormForgeJsonSubmissionValue, FormForgeSubmissionPayload, FormForgeSubmissionResponse, FormForgeResponsesListResponse, FormForgeSubmissionValue, FormForgeUploadMode, FormForgeDatetimeMode, FormForgeRangeValue, FormForgeStagedUploadValue, FormForgeDirectUploadValue } from './api.js';
+export type { FormForgeClient } from '../api/client.js';
+export type { FormForgeManagementCreateInput, FormForgeManagementPatchInput, FormForgeManagementForm, FormForgeRevisionSummary, FormForgeDiffResponse } from './management.js';
+export type { FormForgeJsonObject, FormForgeJsonPrimitive, FormForgeJsonValue } from './json.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/types/json.d.ts

@@ -0,0 +1,6 @@
+export type FormForgeJsonPrimitive = string | number | boolean | null;
+export interface FormForgeJsonObject {
+    [key: string]: FormForgeJsonValue;
+}
+export type FormForgeJsonValue = FormForgeJsonPrimitive | FormForgeJsonObject | FormForgeJsonValue[];
+//# sourceMappingURL=json.d.ts.map

package/dist/runtime/types/management.d.ts

@@ -0,0 +1,46 @@
+import type { FormForgeCondition, FormForgeDraftSettings, FormForgeFieldSchema, FormForgePageSchema } from './schema.js';
+import type { FormForgeJsonObject } from './json.js';
+import type { FormForgeCategory } from './category.js';
+export interface FormForgeManagementCreateInput {
+    title: string;
+    fields?: FormForgeFieldSchema[];
+    pages?: FormForgePageSchema[];
+    conditions?: FormForgeCondition[];
+    drafts?: FormForgeDraftSettings;
+    category?: string | null;
+    meta?: FormForgeJsonObject;
+    api?: FormForgeJsonObject;
+}
+export interface FormForgeManagementPatchInput {
+    title?: string;
+    fields?: FormForgeFieldSchema[];
+    pages?: FormForgePageSchema[];
+    conditions?: FormForgeCondition[];
+    drafts?: FormForgeDraftSettings;
+    category?: string | null;
+    meta?: FormForgeJsonObject;
+    api?: FormForgeJsonObject;
+}
+export type FormForgeManagementForm = FormForgeJsonObject & {
+    id?: string | number;
+    uuid?: string;
+    key?: string;
+    title?: string;
+    category?: string | null;
+    is_published?: boolean;
+    deleted_at?: string | null;
+    category_item?: FormForgeCategory | null;
+};
+export interface FormForgeRevisionSummary {
+    revision_id: string;
+    version_number: number;
+    is_published: boolean;
+    created_at?: string;
+    deleted_at?: string | null;
+}
+export interface FormForgeDiffResponse {
+    from_version: number;
+    to_version: number;
+    changes: FormForgeJsonObject[];
+}
+//# sourceMappingURL=management.d.ts.map

package/dist/runtime/types/nuxt.d.ts

@@ -0,0 +1,13 @@
+import type { FormForgeClient } from '../api/client.js';
+declare module '#app' {
+    interface NuxtApp {
+        $formforge: FormForgeClient;
+    }
+}
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $formforge: FormForgeClient;
+    }
+}
+export {};
+//# sourceMappingURL=nuxt.d.ts.map

package/dist/runtime/types/nuxt.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/types/schema.d.ts

@@ -0,0 +1,93 @@
+import type { FormForgeJsonObject, FormForgeJsonValue } from './json.js';
+import type { FormForgeCategory } from './category.js';
+export type FormForgeFieldType = 'text' | 'textarea' | 'email' | 'number' | 'select' | 'select_menu' | 'radio' | 'checkbox' | 'checkbox_group' | 'switch' | 'date' | 'time' | 'datetime' | 'date_range' | 'datetime_range' | 'file';
+export type FormForgeOptionValue = string | number | boolean | null;
+export interface FormForgeFieldOptionObject {
+    label?: string;
+    value: FormForgeOptionValue;
+    description?: string;
+    disabled?: boolean;
+    [key: string]: FormForgeJsonValue | undefined;
+}
+export type FormForgeFieldOption = FormForgeOptionValue | FormForgeFieldOptionObject;
+export interface FormForgeFieldStorage {
+    disk: string;
+    directory: string;
+    visibility: 'public' | 'private' | string;
+}
+export interface FormForgeFieldSchemaBase<TType extends FormForgeFieldType> {
+    field_key: string;
+    type: TType;
+    name: string;
+    page_key: string;
+    label?: string;
+    required: boolean;
+    nullable: boolean;
+    default: FormForgeJsonValue;
+    rules: string[];
+    meta: FormForgeJsonObject;
+    placeholder?: string;
+    help_text?: string;
+    min?: number | string | null;
+    max?: number | string | null;
+    step?: number | string | null;
+    multiple?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    options?: FormForgeFieldOption[];
+}
+export type FormForgeTextLikeFieldSchema = FormForgeFieldSchemaBase<'text' | 'textarea' | 'email'>;
+export type FormForgeNumberFieldSchema = FormForgeFieldSchemaBase<'number'>;
+export type FormForgeSelectLikeFieldSchema = FormForgeFieldSchemaBase<'select' | 'select_menu' | 'radio' | 'checkbox_group'>;
+export type FormForgeBooleanFieldSchema = FormForgeFieldSchemaBase<'checkbox' | 'switch'>;
+export type FormForgeDateLikeFieldSchema = FormForgeFieldSchemaBase<'date' | 'time' | 'datetime' | 'date_range' | 'datetime_range'>;
+export interface FormForgeFileFieldSchema extends FormForgeFieldSchemaBase<'file'> {
+    accept?: string[];
+    max_size?: number | null;
+    max_files?: number | null;
+    storage?: FormForgeFieldStorage | null;
+}
+export type FormForgeFieldSchema = FormForgeTextLikeFieldSchema | FormForgeNumberFieldSchema | FormForgeSelectLikeFieldSchema | FormForgeBooleanFieldSchema | FormForgeDateLikeFieldSchema | FormForgeFileFieldSchema;
+export interface FormForgePageSchema {
+    page_key: string;
+    title: string;
+    description?: string | null;
+    meta: FormForgeJsonObject;
+    fields: FormForgeFieldSchema[];
+}
+export type FormForgeConditionTargetType = 'page' | 'field';
+export type FormForgeConditionAction = 'show' | 'hide' | 'skip' | 'require' | 'disable';
+export type FormForgeConditionMatch = 'all' | 'any';
+export type FormForgeConditionOperator = 'eq' | 'neq' | 'in' | 'not_in' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'not_contains' | 'is_empty' | 'not_empty';
+export interface FormForgeConditionClause {
+    field_key: string;
+    operator: FormForgeConditionOperator;
+    value: FormForgeJsonValue;
+}
+export interface FormForgeCondition {
+    condition_key: string;
+    target_type: FormForgeConditionTargetType;
+    target_key: string;
+    action: FormForgeConditionAction;
+    match: FormForgeConditionMatch;
+    when: FormForgeConditionClause[];
+}
+export interface FormForgeDraftSettings {
+    enabled: boolean;
+    [key: string]: FormForgeJsonValue | undefined;
+}
+export interface FormForgeFormSchema {
+    key: string;
+    version: string;
+    title: string;
+    category?: string | null;
+    category_item?: FormForgeCategory | null;
+    is_published: boolean;
+    fields: FormForgeFieldSchema[];
+    pages: FormForgePageSchema[];
+    conditions: FormForgeCondition[];
+    drafts: FormForgeDraftSettings;
+    api: FormForgeJsonObject;
+    meta?: FormForgeJsonObject;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/runtime/utils/category.d.ts

@@ -0,0 +1,5 @@
+import type { FormForgeCategory, FormForgeCategoryListResponse, FormForgeCategorySelectOption, FormForgeJsonObject } from '../types/index.js';
+export declare function normalizeFormForgeCategory(value: unknown): FormForgeCategory | null;
+export declare function normalizeFormForgeCategoryListResponse(payload: FormForgeJsonObject): FormForgeCategoryListResponse;
+export declare function normalizeFormForgeCategoryOptions(categories: FormForgeCategory[], includeInactive?: boolean): FormForgeCategorySelectOption[];
+//# sourceMappingURL=category.d.ts.map

package/dist/runtime/utils/category.js

@@ -0,0 +1,101 @@
+import { isFormForgeJsonObject } from "./object.js";
+function toStringOrNull(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null) {
+    return null;
+  }
+  return null;
+}
+function toBoolean(value, fallback) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return fallback;
+}
+function toNumber(value, fallback) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return fallback;
+}
+function asJsonObjectArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const items = [];
+  for (const item of value) {
+    if (isFormForgeJsonObject(item)) {
+      items.push(item);
+    }
+  }
+  return items;
+}
+function normalizePaginationMeta(value) {
+  if (!isFormForgeJsonObject(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizePaginationLinks(value) {
+  if (!isFormForgeJsonObject(value)) {
+    return void 0;
+  }
+  return value;
+}
+function pickPaginationPayload(payload) {
+  const envelope = payload.data;
+  if (isFormForgeJsonObject(envelope) && Array.isArray(envelope.data)) {
+    return envelope;
+  }
+  return payload;
+}
+export function normalizeFormForgeCategory(value) {
+  if (!isFormForgeJsonObject(value)) {
+    return null;
+  }
+  const category = value;
+  const meta = isFormForgeJsonObject(category.meta) ? category.meta : {};
+  return {
+    id: toNumber(category.id, 0),
+    key: typeof category.key === "string" ? category.key : "",
+    name: typeof category.name === "string" ? category.name : "",
+    description: toStringOrNull(category.description),
+    is_active: toBoolean(category.is_active, false),
+    meta,
+    created_at: toStringOrNull(category.created_at),
+    updated_at: toStringOrNull(category.updated_at)
+  };
+}
+export function normalizeFormForgeCategoryListResponse(payload) {
+  const paginationPayload = pickPaginationPayload(payload);
+  const rawItems = asJsonObjectArray(paginationPayload.data);
+  const categories = [];
+  for (const rawItem of rawItems) {
+    const item = normalizeFormForgeCategory(rawItem);
+    if (item !== null) {
+      categories.push(item);
+    }
+  }
+  return {
+    data: categories,
+    meta: normalizePaginationMeta(paginationPayload.meta ?? payload.meta),
+    links: normalizePaginationLinks(paginationPayload.links ?? payload.links)
+  };
+}
+export function normalizeFormForgeCategoryOptions(categories, includeInactive = true) {
+  const sortable = [...categories].sort((left, right) => left.name.localeCompare(right.name));
+  const options = [];
+  for (const category of sortable) {
+    if (!includeInactive && category.is_active === false) {
+      continue;
+    }
+    options.push({
+      label: category.name,
+      value: category.key,
+      disabled: category.is_active === false
+    });
+  }
+  return options;
+}

package/dist/runtime/utils/form-data.d.ts

@@ -0,0 +1,8 @@
+import type { FormForgeJsonObject, FormForgeJsonSubmissionPayload, FormForgeSubmissionValue } from '../types/index.js';
+export type FormForgeManagedValue = FormForgeSubmissionValue | File | File[];
+export interface FormForgeManagedPayload {
+    [key: string]: FormForgeManagedValue;
+}
+export declare function buildManagedFormData(payload: FormForgeManagedPayload, meta?: FormForgeJsonObject): FormData;
+export declare function buildJsonSubmitBody(payload: FormForgeJsonSubmissionPayload, meta?: FormForgeJsonObject): FormForgeJsonObject;
+//# sourceMappingURL=form-data.d.ts.map

package/dist/runtime/utils/form-data.js

@@ -0,0 +1,64 @@
+function isFileValue(value) {
+  if (typeof File === "undefined") {
+    return false;
+  }
+  return value instanceof File;
+}
+function appendJsonValue(formData, key, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    formData.append(key, String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      appendJsonValue(formData, `${key}[${index}]`, item);
+    });
+    return;
+  }
+  for (const [childKey, childValue] of Object.entries(value)) {
+    appendJsonValue(formData, `${key}[${childKey}]`, childValue);
+  }
+}
+export function buildManagedFormData(payload, meta) {
+  const formData = new FormData();
+  for (const [fieldName, fieldValue] of Object.entries(payload)) {
+    if (fieldValue === void 0) {
+      continue;
+    }
+    if (isFileValue(fieldValue)) {
+      formData.append(fieldName, fieldValue);
+      continue;
+    }
+    if (Array.isArray(fieldValue) && fieldValue.every((item) => isFileValue(item))) {
+      for (const file of fieldValue) {
+        if (isFileValue(file)) {
+          formData.append(fieldName, file);
+        }
+      }
+      continue;
+    }
+    appendJsonValue(formData, `payload[${fieldName}]`, fieldValue);
+  }
+  if (meta !== void 0) {
+    for (const [metaKey, metaValue] of Object.entries(meta)) {
+      appendJsonValue(formData, `meta[${metaKey}]`, metaValue);
+    }
+  }
+  return formData;
+}
+export function buildJsonSubmitBody(payload, meta) {
+  const body = {
+    payload
+  };
+  if (meta !== void 0) {
+    body.meta = meta;
+  }
+  return body;
+}

package/dist/runtime/utils/object.d.ts

@@ -0,0 +1,8 @@
+import type { FormForgeJsonObject, FormForgeJsonValue } from '../types/index.js';
+export declare function isFormForgeJsonObject(value: FormForgeJsonValue | null | undefined): value is FormForgeJsonObject;
+export declare function getFormForgeString(value: FormForgeJsonValue | undefined): string | undefined;
+export declare function getFormForgeNumber(value: FormForgeJsonValue | undefined): number | undefined;
+export declare function getFormForgeBoolean(value: FormForgeJsonValue | undefined): boolean | undefined;
+export declare function getFormForgeStringArray(value: FormForgeJsonValue | undefined): string[] | undefined;
+export declare function pickFormForgeDataEnvelope(payload: FormForgeJsonObject): FormForgeJsonObject;
+//# sourceMappingURL=object.d.ts.map

package/dist/runtime/utils/object.js

@@ -0,0 +1,43 @@
+export function isFormForgeJsonObject(value) {
+  if (value === null) {
+    return false;
+  }
+  return !Array.isArray(value) && typeof value === "object";
+}
+export function getFormForgeString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return void 0;
+}
+export function getFormForgeNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return void 0;
+}
+export function getFormForgeBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return void 0;
+}
+export function getFormForgeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const items = [];
+  for (const item of value) {
+    if (typeof item === "string") {
+      items.push(item);
+    }
+  }
+  return items;
+}
+export function pickFormForgeDataEnvelope(payload) {
+  const value = payload.data;
+  if (isFormForgeJsonObject(value)) {
+    return value;
+  }
+  return payload;
+}

package/dist/runtime/utils/schema.d.ts

@@ -0,0 +1,3 @@
+import type { FormForgeFormSchema, FormForgeJsonObject } from '../types/index.js';
+export declare function normalizeFormForgeSchema(payload: FormForgeJsonObject): FormForgeFormSchema;
+//# sourceMappingURL=schema.d.ts.map