@evanschleret/formforgeclient 1.0.0

package/dist/runtime/api/responses.js

@@ -0,0 +1,61 @@
+import { isFormForgeJsonObject, pickFormForgeDataEnvelope } from "../utils/object.js";
+import { resolveEndpointPath } from "./request.js";
+function asJsonObjectArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const items = [];
+  for (const item of value) {
+    if (isFormForgeJsonObject(item)) {
+      items.push(item);
+    }
+  }
+  return items;
+}
+function normalizeResponsesList(payload) {
+  const dataValue = payload.data;
+  if (Array.isArray(dataValue)) {
+    return asJsonObjectArray(dataValue);
+  }
+  if (!isFormForgeJsonObject(dataValue)) {
+    return asJsonObjectArray(payload.items ?? payload.responses ?? payload.submissions);
+  }
+  const nestedData = dataValue.data;
+  if (Array.isArray(nestedData)) {
+    return asJsonObjectArray(nestedData);
+  }
+  return asJsonObjectArray(dataValue.items ?? dataValue.responses ?? dataValue.submissions);
+}
+export async function fetchFormForgeResponses(http, key, query = {}, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/responses`, {
+      key
+    }, options.scope),
+    method: "GET",
+    query
+  });
+  return {
+    data: normalizeResponsesList(response.data),
+    meta: isFormForgeJsonObject(response.data.meta) ? response.data.meta : void 0
+  };
+}
+export async function fetchFormForgeResponse(http, key, submissionId, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/responses/${submissionId}`, {
+      key,
+      submissionId
+    }, options.scope),
+    method: "GET"
+  });
+  return pickFormForgeDataEnvelope(response.data);
+}
+export async function deleteFormForgeResponse(http, key, submissionId, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/responses/${submissionId}`, {
+      key,
+      submissionId
+    }, options.scope),
+    method: "DELETE"
+  });
+  return pickFormForgeDataEnvelope(response.data);
+}

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

@@ -0,0 +1,7 @@
+import type { FormForgeFormSchema, FormForgeHttpAdapter, FormForgeResolveInput, FormForgeSchemaVersionsResponse } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+export declare function fetchFormForgeSchema(http: FormForgeHttpAdapter, key: string, options?: FormForgeRequestOptions): Promise<FormForgeFormSchema>;
+export declare function fetchFormForgeSchemaVersions(http: FormForgeHttpAdapter, key: string, options?: FormForgeRequestOptions): Promise<FormForgeSchemaVersionsResponse>;
+export declare function fetchFormForgeSchemaVersion(http: FormForgeHttpAdapter, key: string, version: string, options?: FormForgeRequestOptions): Promise<FormForgeFormSchema>;
+export declare function resolveFormForgeSchema(http: FormForgeHttpAdapter, key: string, input?: FormForgeResolveInput, version?: string, options?: FormForgeRequestOptions): Promise<FormForgeFormSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/runtime/api/schema.js

@@ -0,0 +1,56 @@
+import { isFormForgeJsonObject, pickFormForgeDataEnvelope } from "../utils/object.js";
+import { normalizeFormForgeSchema } from "../utils/schema.js";
+import { resolveEndpointPath } from "./request.js";
+export async function fetchFormForgeSchema(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}`, {
+      key
+    }, options.scope),
+    method: "GET"
+  });
+  return normalizeFormForgeSchema(response.data);
+}
+export async function fetchFormForgeSchemaVersions(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/versions`, {
+      key
+    }, options.scope),
+    method: "GET"
+  });
+  return {
+    data: pickFormForgeDataEnvelope(response.data),
+    meta: response.data.meta
+  };
+}
+export async function fetchFormForgeSchemaVersion(http, key, version, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/versions/${version}`, {
+      key,
+      version
+    }, options.scope),
+    method: "GET"
+  });
+  return normalizeFormForgeSchema(response.data);
+}
+export async function resolveFormForgeSchema(http, key, input = {}, version, options = {}) {
+  const fallbackPath = version !== void 0 && version !== "" ? `/forms/${key}/versions/${version}/resolve` : `/forms/${key}/resolve`;
+  const path = resolveEndpointPath(options.endpoint, fallbackPath, {
+    key,
+    version: version ?? ""
+  }, options.scope);
+  const body = {
+    payload: JSON.parse(JSON.stringify(input.payload ?? {})),
+    debug: input.debug === true
+  };
+  const response = await http({
+    path,
+    method: "POST",
+    json: body
+  });
+  const data = pickFormForgeDataEnvelope(response.data);
+  const schemaValue = data.schema;
+  if (isFormForgeJsonObject(schemaValue)) {
+    return normalizeFormForgeSchema(schemaValue);
+  }
+  return normalizeFormForgeSchema(data);
+}

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

@@ -0,0 +1,11 @@
+import type { FormForgeHttpAdapter, FormForgeSubmitInput, FormForgeSubmissionResponse } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+interface FormForgeSubmitOptions extends FormForgeRequestOptions {
+    version?: string;
+}
+export declare function submitFormForgeJson(http: FormForgeHttpAdapter, key: string, input: FormForgeSubmitInput, options?: FormForgeSubmitOptions): Promise<FormForgeSubmissionResponse>;
+export declare function submitFormForgeMultipart(http: FormForgeHttpAdapter, key: string, formData: FormData, options?: FormForgeSubmitOptions & {
+    test?: boolean;
+}): Promise<FormForgeSubmissionResponse>;
+export {};
+//# sourceMappingURL=submission.d.ts.map

package/dist/runtime/api/submission.js

@@ -0,0 +1,47 @@
+import { buildJsonSubmitBody } from "../utils/form-data.js";
+import { pickFormForgeDataEnvelope } from "../utils/object.js";
+import { resolveEndpointPath } from "./request.js";
+function buildSubmitPath(key, version) {
+  if (version !== void 0 && version !== "") {
+    return `/forms/${key}/versions/${version}/submit`;
+  }
+  return `/forms/${key}/submit`;
+}
+export async function submitFormForgeJson(http, key, input, options = {}) {
+  const headers = {};
+  if (input.test === true) {
+    headers["X-FormForge-Test"] = "true";
+  }
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, buildSubmitPath(key, options.version), {
+      key,
+      version: options.version ?? ""
+    }, options.scope),
+    method: "POST",
+    headers,
+    json: buildJsonSubmitBody(input.payload, input.meta)
+  });
+  return {
+    data: pickFormForgeDataEnvelope(response.data),
+    meta: response.data.meta
+  };
+}
+export async function submitFormForgeMultipart(http, key, formData, options = {}) {
+  const headers = {};
+  if (options.test === true) {
+    headers["X-FormForge-Test"] = "true";
+  }
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, buildSubmitPath(key, options.version), {
+      key,
+      version: options.version ?? ""
+    }, options.scope),
+    method: "POST",
+    headers,
+    body: formData
+  });
+  return {
+    data: pickFormForgeDataEnvelope(response.data),
+    meta: response.data.meta
+  };
+}

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

@@ -0,0 +1,8 @@
+import type { FormForgeHttpAdapter, FormForgeStageUploadInput, FormForgeStagedUploadResponse } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+interface FormForgeStageUploadOptions extends FormForgeRequestOptions {
+    version?: string;
+}
+export declare function stageFormForgeUpload(http: FormForgeHttpAdapter, key: string, input: FormForgeStageUploadInput, options?: FormForgeStageUploadOptions): Promise<FormForgeStagedUploadResponse>;
+export {};
+//# sourceMappingURL=upload.d.ts.map

package/dist/runtime/api/upload.js

@@ -0,0 +1,37 @@
+import { pickFormForgeDataEnvelope } from "../utils/object.js";
+import { resolveEndpointPath } from "./request.js";
+function buildUploadPath(key, version) {
+  if (version !== void 0 && version !== "") {
+    return `/forms/${key}/versions/${version}/uploads/stage`;
+  }
+  return `/forms/${key}/uploads/stage`;
+}
+export async function stageFormForgeUpload(http, key, input, options = {}) {
+  const formData = new FormData();
+  if (input.field !== void 0) {
+    formData.append("field", input.field);
+  }
+  if (input.field_key !== void 0) {
+    formData.append("field_key", input.field_key);
+  }
+  formData.append("file", input.file);
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, buildUploadPath(key, options.version), {
+      key,
+      version: options.version ?? ""
+    }, options.scope),
+    method: "POST",
+    body: formData
+  });
+  const data = pickFormForgeDataEnvelope(response.data);
+  const stagedValue = data.staged;
+  return {
+    data: {
+      staged: {
+        upload_token: String(stagedValue.upload_token ?? ""),
+        expires_at: typeof stagedValue.expires_at === "string" ? stagedValue.expires_at : void 0
+      }
+    },
+    meta: response.data.meta
+  };
+}

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

@@ -0,0 +1,31 @@
+export { useFormForgeApi } from './useFormForgeApi.js';
+export { useFormForgeClient } from './useFormForgeClient.js';
+export { useFormForgeSchema } from './useFormForgeSchema.js';
+export { useFormForgeGetForm } from './useFormForgeGetForm.js';
+export { useFormForgeI18n } from './useFormForgeI18n.js';
+export { useFormForgeResolver } from './useFormForgeResolver.js';
+export { useFormForgeDrafts } from './useFormForgeDrafts.js';
+export { useFormForgeUploads } from './useFormForgeUploads.js';
+export { useFormForgeForm } from './useFormForgeForm.js';
+export { useFormForgeSubmit } from './useFormForgeSubmit.js';
+export { useFormForgeSubmission } from './useFormForgeSubmission.js';
+export { useFormForgeResponses } from './useFormForgeResponses.js';
+export { useFormForgeCategory, useFormForgeCategoryOptions, normalizeFormForgeCategoryOptions } from './useFormForgeCategory.js';
+export { useFormForgeManagement } from './useFormForgeManagement.js';
+export { useFormForgeWizard } from './useFormForgeWizard.js';
+export { useFormForgeBuilder } from './useFormForgeBuilder.js';
+export type { UseFormForgeSchemaOptions, FormForgeSchemaFetchOptions } from './useFormForgeSchema.js';
+export type { UseFormForgeGetFormOptions, FormForgeGetFormParams } from './useFormForgeGetForm.js';
+export type { UseFormForgeI18nOptions, FormForgeLocale } from './useFormForgeI18n.js';
+export type { UseFormForgeResolverOptions, FormForgeResolveOptions } from './useFormForgeResolver.js';
+export type { UseFormForgeDraftsOptions, FormForgeDraftRequestOptions } from './useFormForgeDrafts.js';
+export type { UseFormForgeUploadsOptions, FormForgeUploadOptions } from './useFormForgeUploads.js';
+export type { UseFormForgeFormOptions, FormForgeFormRequestOptions } from './useFormForgeForm.js';
+export type { UseFormForgeSubmitOptions, FormForgeSubmitOptions } from './useFormForgeSubmit.js';
+export type { UseFormForgeSubmissionOptions, FormForgeSubmissionOptions } from './useFormForgeSubmission.js';
+export type { UseFormForgeResponsesOptions, UseFormForgeResponsesQuerySync, FormForgeResponsesRefreshOptions, FormForgeResponsesRequestOptions } from './useFormForgeResponses.js';
+export type { UseFormForgeCategoryOptions, FormForgeCategoryRequestOptions, FormForgeCategoryRefreshOptions, UseFormForgeCategoryOptionsHelperInput } from './useFormForgeCategory.js';
+export type { UseFormForgeManagementOptions, UseFormForgeManagementMutationInputOptions } from './useFormForgeManagement.js';
+export type { UseFormForgeWizardOptions } from './useFormForgeWizard.js';
+export type { UseFormForgeBuilderOptions, FormForgeBuilderDraft } from './useFormForgeBuilder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/composables/index.js

@@ -0,0 +1,16 @@
+export { useFormForgeApi } from "./useFormForgeApi.js";
+export { useFormForgeClient } from "./useFormForgeClient.js";
+export { useFormForgeSchema } from "./useFormForgeSchema.js";
+export { useFormForgeGetForm } from "./useFormForgeGetForm.js";
+export { useFormForgeI18n } from "./useFormForgeI18n.js";
+export { useFormForgeResolver } from "./useFormForgeResolver.js";
+export { useFormForgeDrafts } from "./useFormForgeDrafts.js";
+export { useFormForgeUploads } from "./useFormForgeUploads.js";
+export { useFormForgeForm } from "./useFormForgeForm.js";
+export { useFormForgeSubmit } from "./useFormForgeSubmit.js";
+export { useFormForgeSubmission } from "./useFormForgeSubmission.js";
+export { useFormForgeResponses } from "./useFormForgeResponses.js";
+export { useFormForgeCategory, useFormForgeCategoryOptions, normalizeFormForgeCategoryOptions } from "./useFormForgeCategory.js";
+export { useFormForgeManagement } from "./useFormForgeManagement.js";
+export { useFormForgeWizard } from "./useFormForgeWizard.js";
+export { useFormForgeBuilder } from "./useFormForgeBuilder.js";

package/dist/runtime/composables/useFormForgeApi.d.ts

@@ -0,0 +1,3 @@
+import type { FormForgeClient, FormForgeClientConfig } from '../types/index.js';
+export declare function useFormForgeApi(config?: FormForgeClientConfig): FormForgeClient;
+//# sourceMappingURL=useFormForgeApi.d.ts.map

package/dist/runtime/composables/useFormForgeApi.js

@@ -0,0 +1,4 @@
+import { useFormForgeClient } from "./useFormForgeClient.js";
+export function useFormForgeApi(config = {}) {
+  return useFormForgeClient(config);
+}

package/dist/runtime/composables/useFormForgeBuilder.d.ts

@@ -0,0 +1,57 @@
+import type { FormForgeClient, FormForgeClientConfig, FormForgeCondition, FormForgeConditionAction, FormForgeConditionMatch, FormForgeConditionOperator, FormForgeConditionTargetType, FormForgeDraftSettings, FormForgeFieldType, FormForgeScope, FormForgePageSchema } from '../types/index.js';
+export interface FormForgeBuilderDraft {
+    uuid: string | null;
+    key: string | null;
+    title: string;
+    category: string | null;
+    pages: FormForgePageSchema[];
+    conditions: FormForgeCondition[];
+    drafts: FormForgeDraftSettings;
+}
+export interface UseFormForgeBuilderOptions {
+    formUuid?: string;
+    formKey?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    initial?: Partial<FormForgeBuilderDraft>;
+    autosave?: boolean;
+    autosaveDelay?: number;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export declare const FORM_FORGE_BUILDER_FIELD_TYPES: FormForgeFieldType[];
+export declare const FORM_FORGE_BUILDER_CONDITION_TARGET_TYPES: FormForgeConditionTargetType[];
+export declare const FORM_FORGE_BUILDER_CONDITION_ACTIONS: FormForgeConditionAction[];
+export declare const FORM_FORGE_BUILDER_CONDITION_MATCHES: FormForgeConditionMatch[];
+export declare const FORM_FORGE_BUILDER_CONDITION_OPERATORS: FormForgeConditionOperator[];
+export declare function useFormForgeBuilder(options?: UseFormForgeBuilderOptions): {
+    client: FormForgeClient;
+    loading: any;
+    saving: any;
+    publishing: any;
+    error: any;
+    draft: {
+        value: FormForgeBuilderDraft;
+    };
+    autosaveEnabled: any;
+    autosaveDelay: any;
+    lastSavedAt: any;
+    publishable: any;
+    addPage: () => void;
+    removePage: (pageKey: string) => void;
+    mergePageWithPrevious: (pageKey: string) => void;
+    addField: (pageKey: string, type: FormForgeFieldType) => void;
+    duplicateField: (pageKey: string, fieldKey: string) => void;
+    removeField: (pageKey: string, fieldKey: string) => void;
+    addCondition: () => void;
+    removeCondition: (conditionKey: string) => void;
+    addConditionClause: (conditionKey: string) => void;
+    removeConditionClause: (conditionKey: string, index: number) => void;
+    normalizeFieldLocations: () => void;
+    save: (idempotencyKey?: string) => Promise<void>;
+    publish: (idempotencyKey?: string) => Promise<void>;
+    unpublish: (idempotencyKey?: string) => Promise<void>;
+    clearAutosave: () => void;
+    scheduleAutosave: () => void;
+};
+//# sourceMappingURL=useFormForgeBuilder.d.ts.map