@evanschleret/formforgeclient 1.0.0

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

@@ -0,0 +1,29 @@
+import type { FormForgeRequestOptions } from '../api/request.js';
+import type { FormForgeClient, FormForgeClientConfig, FormForgeFormSchema, FormForgeJsonObject, FormForgeScope, FormForgeSubmissionPayload, FormForgeSubmissionResponse, FormForgeUploadMode } from '../types/index.js';
+export interface UseFormForgeSubmitOptions {
+    key: string;
+    schema: () => FormForgeFormSchema | null;
+    state: () => FormForgeSubmissionPayload;
+    version?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+    validateLocal?: boolean;
+}
+export interface FormForgeSubmitOptions extends FormForgeRequestOptions {
+    mode?: FormForgeUploadMode;
+    version?: string;
+    meta?: FormForgeJsonObject;
+    test?: boolean;
+    validateLocal?: boolean;
+}
+export declare function useFormForgeSubmit(options: UseFormForgeSubmitOptions): {
+    client: FormForgeClient;
+    submitting: any;
+    fieldErrors: any;
+    error: any;
+    response: any;
+    submit: (submitOptions?: FormForgeSubmitOptions) => Promise<FormForgeSubmissionResponse>;
+};
+//# sourceMappingURL=useFormForgeSubmit.d.ts.map

package/dist/runtime/composables/useFormForgeSubmit.js

@@ -0,0 +1,291 @@
+import { ref } from "#imports";
+import { buildManagedFormData } from "../utils/form-data.js";
+import { toFormForgeJsonSubmissionPayload } from "../utils/submission.js";
+import { createFormForgeZodSchema, validateFormForgePayload } from "../validation/zod.js";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+const RESERVED_SUBMISSION_FIELD_NAMES = [
+  "submitted_by_id",
+  "submitted_by_type",
+  "type",
+  "updated_at",
+  "ip_address"
+];
+function isReservedSubmissionFieldName(fieldName) {
+  return RESERVED_SUBMISSION_FIELD_NAMES.includes(fieldName);
+}
+function isFileValue(value) {
+  if (typeof File === "undefined") {
+    return false;
+  }
+  return value instanceof File;
+}
+function isStagedUploadToken(value) {
+  if (value === null || Array.isArray(value) || typeof value !== "object") {
+    return false;
+  }
+  const uploadToken = value.upload_token;
+  return typeof uploadToken === "string";
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  if (typeof File !== "undefined" && value instanceof File) {
+    return false;
+  }
+  return true;
+}
+function hasUploadTokenOrPath(value) {
+  const uploadToken = value.upload_token;
+  if (typeof uploadToken === "string" && uploadToken.trim() !== "") {
+    return true;
+  }
+  const path = value.path;
+  if (typeof path === "string" && path.trim() !== "") {
+    return true;
+  }
+  return false;
+}
+function isEmptyFileSubmissionValue(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (isFileValue(value) || isStagedUploadToken(value)) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return true;
+    }
+    return value.every((item) => {
+      if (item === void 0 || item === null) {
+        return true;
+      }
+      if (isFileValue(item)) {
+        return false;
+      }
+      if (isStagedUploadToken(item)) {
+        return false;
+      }
+      if (isPlainObject(item)) {
+        return !hasUploadTokenOrPath(item);
+      }
+      return false;
+    });
+  }
+  if (isPlainObject(value)) {
+    return !hasUploadTokenOrPath(value);
+  }
+  return false;
+}
+function isOptionalFieldValueAbsent(field, value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return true;
+  }
+  if (field.type === "file") {
+    return isEmptyFileSubmissionValue(value);
+  }
+  if (field.type === "checkbox_group" && Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  if ((field.type === "date_range" || field.type === "datetime_range") && isPlainObject(value)) {
+    const start = value.start;
+    const end = value.end;
+    const startEmpty = start === void 0 || start === null || start === "";
+    const endEmpty = end === void 0 || end === null || end === "";
+    return startEmpty && endEmpty;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  return false;
+}
+function isFormForgeClientError(error) {
+  const maybeError = error;
+  return typeof maybeError.status === "number" && typeof maybeError.code === "string" && typeof maybeError.message === "string";
+}
+async function stageSingleFile(client, formKey, field, file, version, endpoint, scope) {
+  const staged = await client.stageUpload(
+    formKey,
+    {
+      field: field.name,
+      field_key: field.field_key,
+      file
+    },
+    {
+      version,
+      endpoint,
+      scope
+    }
+  );
+  return {
+    upload_token: staged.data.staged.upload_token
+  };
+}
+async function stageFieldFiles(client, formKey, field, value, version, endpoint, scope) {
+  if (value === null || value === void 0 || isStagedUploadToken(value)) {
+    return value;
+  }
+  if (isFileValue(value)) {
+    return stageSingleFile(client, formKey, field, value, version, endpoint, scope);
+  }
+  if (Array.isArray(value)) {
+    const stagedValues = [];
+    for (const item of value) {
+      if (isFileValue(item)) {
+        const stagedItem = await stageSingleFile(client, formKey, field, item, version, endpoint, scope);
+        stagedValues.push(stagedItem);
+      }
+      if (isStagedUploadToken(item)) {
+        stagedValues.push(item);
+      }
+    }
+    return stagedValues;
+  }
+  if (isPlainObject(value)) {
+    return hasUploadTokenOrPath(value) ? value : null;
+  }
+  return value;
+}
+function filterSubmittableFields(schema) {
+  return schema.fields.filter((field) => !isReservedSubmissionFieldName(field.name));
+}
+function buildSubmissionPayload(fields, state) {
+  const payload = {};
+  for (const field of fields) {
+    const fieldValue = state[field.name];
+    if (fieldValue === void 0) {
+      continue;
+    }
+    if (field.required === false && isOptionalFieldValueAbsent(field, fieldValue)) {
+      continue;
+    }
+    payload[field.name] = fieldValue;
+  }
+  return payload;
+}
+function pruneOptionalEmptyFields(payload, fields) {
+  for (const field of fields) {
+    if (field.required !== false) {
+      continue;
+    }
+    if (isOptionalFieldValueAbsent(field, payload[field.name])) {
+      delete payload[field.name];
+    }
+  }
+}
+export function useFormForgeSubmit(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const submitting = ref(false);
+  const fieldErrors = ref({});
+  const error = ref(null);
+  const response = ref(null);
+  async function submit(submitOptions = {}) {
+    const schema = options.schema();
+    if (schema === null) {
+      throw new Error("Schema is not loaded");
+    }
+    const submittableFields = filterSubmittableFields(schema);
+    const submittableSchema = {
+      ...schema,
+      fields: submittableFields
+    };
+    const mode = submitOptions.mode ?? options.clientConfig?.uploadMode ?? "staged";
+    const version = submitOptions.version ?? options.version;
+    const endpoint = submitOptions.endpoint ?? options.endpoint;
+    const scope = submitOptions.scope ?? options.scope;
+    const payload = buildSubmissionPayload(submittableFields, options.state());
+    pruneOptionalEmptyFields(payload, submittableFields);
+    fieldErrors.value = {};
+    error.value = null;
+    submitting.value = true;
+    try {
+      const shouldValidateLocal = submitOptions.validateLocal ?? options.validateLocal ?? true;
+      if (shouldValidateLocal) {
+        const localSchema = createFormForgeZodSchema(submittableSchema);
+        const localErrors = validateFormForgePayload(localSchema, payload);
+        if (Object.keys(localErrors).length > 0) {
+          fieldErrors.value = localErrors;
+          throw {
+            status: 422,
+            code: "validation",
+            message: "Validation failed",
+            fieldErrors: localErrors
+          };
+        }
+      }
+      if (mode === "managed") {
+        const formData = buildManagedFormData(payload, submitOptions.meta);
+        const managedResponse = await client.submitFormMultipart(options.key, formData, {
+          version,
+          test: submitOptions.test,
+          endpoint,
+          scope
+        });
+        response.value = managedResponse;
+        return managedResponse;
+      }
+      const jsonPayload = {
+        ...payload
+      };
+      if (mode === "staged") {
+        for (const field of submittableFields) {
+          if (field.type !== "file") {
+            continue;
+          }
+          const currentValue = jsonPayload[field.name];
+          if (currentValue === void 0) {
+            continue;
+          }
+          const stagedValue = await stageFieldFiles(client, options.key, field, currentValue, version, endpoint, scope);
+          if (stagedValue === void 0) {
+            delete jsonPayload[field.name];
+            continue;
+          }
+          jsonPayload[field.name] = stagedValue;
+        }
+      }
+      pruneOptionalEmptyFields(jsonPayload, submittableFields);
+      const submitResponse = await client.submitForm(
+        options.key,
+        {
+          payload: toFormForgeJsonSubmissionPayload(jsonPayload),
+          meta: submitOptions.meta,
+          test: submitOptions.test
+        },
+        {
+          version,
+          endpoint,
+          scope
+        }
+      );
+      response.value = submitResponse;
+      return submitResponse;
+    } catch (caughtError) {
+      if (typeof caughtError === "object" && caughtError !== null && isFormForgeClientError(caughtError)) {
+        error.value = caughtError;
+        fieldErrors.value = caughtError.fieldErrors ?? {};
+      } else {
+        error.value = {
+          status: 0,
+          code: "network_error",
+          message: caughtError instanceof Error ? caughtError.message : "Submission failed"
+        };
+      }
+      throw error.value;
+    } finally {
+      submitting.value = false;
+    }
+  }
+  return {
+    client,
+    submitting,
+    fieldErrors,
+    error,
+    response,
+    submit
+  };
+}

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

@@ -0,0 +1,21 @@
+import type { FormForgeRequestOptions } from '../api/request.js';
+import type { FormForgeClient, FormForgeClientConfig, FormForgeScope, FormForgeStageUploadInput, FormForgeStagedUploadResponse } from '../types/index.js';
+export interface UseFormForgeUploadsOptions {
+    key: string;
+    version?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export interface FormForgeUploadOptions extends FormForgeRequestOptions {
+    version?: string;
+}
+export declare function useFormForgeUploads(options: UseFormForgeUploadsOptions): {
+    client: FormForgeClient;
+    uploading: any;
+    error: any;
+    lastUpload: any;
+    stageUpload: (input: FormForgeStageUploadInput, stageOptions?: FormForgeUploadOptions) => Promise<FormForgeStagedUploadResponse>;
+};
+//# sourceMappingURL=useFormForgeUploads.d.ts.map

package/dist/runtime/composables/useFormForgeUploads.js

@@ -0,0 +1,37 @@
+import { ref } from "#imports";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+export function useFormForgeUploads(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const uploading = ref(false);
+  const error = ref(null);
+  const lastUpload = ref(null);
+  async function stageUpload(input, stageOptions = {}) {
+    uploading.value = true;
+    error.value = null;
+    try {
+      const response = await client.stageUpload(
+        options.key,
+        input,
+        {
+          version: stageOptions.version ?? options.version,
+          endpoint: stageOptions.endpoint ?? options.endpoint,
+          scope: stageOptions.scope ?? options.scope
+        }
+      );
+      lastUpload.value = response;
+      return response;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to stage upload";
+      throw caughtError;
+    } finally {
+      uploading.value = false;
+    }
+  }
+  return {
+    client,
+    uploading,
+    error,
+    lastUpload,
+    stageUpload
+  };
+}

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

@@ -0,0 +1,20 @@
+import type { FormForgeFormSchema, FormForgePageSchema } from '../types/index.js';
+export interface UseFormForgeWizardOptions {
+    schema: () => FormForgeFormSchema | null;
+    isPageVisible?: (page: FormForgePageSchema, index: number) => boolean;
+}
+export declare function useFormForgeWizard(options: UseFormForgeWizardOptions): {
+    pages: any;
+    visiblePages: any;
+    pageCount: any;
+    pageIndex: any;
+    currentPage: any;
+    canGoPrevious: any;
+    canGoNext: any;
+    setPageIndex: (index: number) => void;
+    nextPage: () => boolean;
+    previousPage: () => boolean;
+    goToPage: (pageKey: string) => boolean;
+    resetWizard: () => void;
+};
+//# sourceMappingURL=useFormForgeWizard.d.ts.map

package/dist/runtime/composables/useFormForgeWizard.js

@@ -0,0 +1,83 @@
+import { computed, ref, watch } from "#imports";
+export function useFormForgeWizard(options) {
+  const pageIndex = ref(0);
+  const pages = computed(() => {
+    const schema = options.schema();
+    if (schema === null) {
+      return [];
+    }
+    return schema.pages;
+  });
+  const visiblePages = computed(() => {
+    if (options.isPageVisible === void 0) {
+      return pages.value;
+    }
+    return pages.value.filter((page, index) => options.isPageVisible?.(page, index) === true);
+  });
+  const pageCount = computed(() => visiblePages.value.length);
+  const currentPage = computed(() => {
+    const nextPage2 = visiblePages.value[pageIndex.value];
+    return nextPage2 ?? null;
+  });
+  const canGoPrevious = computed(() => pageIndex.value > 0);
+  const canGoNext = computed(() => pageIndex.value < pageCount.value - 1);
+  function setPageIndex(index) {
+    if (pageCount.value === 0) {
+      pageIndex.value = 0;
+      return;
+    }
+    if (index < 0) {
+      pageIndex.value = 0;
+      return;
+    }
+    if (index >= pageCount.value) {
+      pageIndex.value = pageCount.value - 1;
+      return;
+    }
+    pageIndex.value = index;
+  }
+  function nextPage() {
+    if (!canGoNext.value) {
+      return false;
+    }
+    setPageIndex(pageIndex.value + 1);
+    return true;
+  }
+  function previousPage() {
+    if (!canGoPrevious.value) {
+      return false;
+    }
+    setPageIndex(pageIndex.value - 1);
+    return true;
+  }
+  function goToPage(pageKey) {
+    const index = visiblePages.value.findIndex((page) => page.page_key === pageKey);
+    if (index < 0) {
+      return false;
+    }
+    setPageIndex(index);
+    return true;
+  }
+  function resetWizard() {
+    setPageIndex(0);
+  }
+  watch(visiblePages, () => {
+    setPageIndex(pageIndex.value);
+  }, {
+    immediate: true
+  });
+  return {
+    pages,
+    visiblePages,
+    pageCount,
+    pageIndex,
+    currentPage,
+    canGoPrevious,
+    canGoNext,
+    setPageIndex,
+    nextPage,
+    previousPage,
+    goToPage,
+    resetWizard
+  };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types/index.js';
+export * from './api/index.js';
+export * from './composables/index.js';
+export * from './renderers/index.js';
+export { createFormForgeZodSchema, mapFormForgeZodIssues, validateFormForgePayload } from './validation/zod.js';
+export { normalizeFormForgeClientError, normalizeNetworkFormForgeError, parseFormForgeValidationPayload } from './validation/errors.js';
+export { buildManagedFormData, buildJsonSubmitBody } from './utils/form-data.js';
+export { toFormForgeJsonSubmissionPayload, toFormForgeJsonSubmissionValue } from './utils/submission.js';
+export { normalizeFormForgeSchema } from './utils/schema.js';
+export { normalizeFormForgeCategory, normalizeFormForgeCategoryListResponse, normalizeFormForgeCategoryOptions } from './utils/category.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -0,0 +1,14 @@
+export * from "./types/index.js";
+export * from "./api/index.js";
+export * from "./composables/index.js";
+export * from "./renderers/index.js";
+export { createFormForgeZodSchema, mapFormForgeZodIssues, validateFormForgePayload } from "./validation/zod.js";
+export { normalizeFormForgeClientError, normalizeNetworkFormForgeError, parseFormForgeValidationPayload } from "./validation/errors.js";
+export { buildManagedFormData, buildJsonSubmitBody } from "./utils/form-data.js";
+export { toFormForgeJsonSubmissionPayload, toFormForgeJsonSubmissionValue } from "./utils/submission.js";
+export { normalizeFormForgeSchema } from "./utils/schema.js";
+export {
+  normalizeFormForgeCategory,
+  normalizeFormForgeCategoryListResponse,
+  normalizeFormForgeCategoryOptions
+} from "./utils/category.js";

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/runtime/plugin.js

@@ -0,0 +1,175 @@
+import { defineNuxtPlugin, useRoute, useRuntimeConfig } from "#imports";
+import { createFormForgeClient } from "./api/index.js";
+function readRouteValue(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const first = value[0];
+    if (typeof first === "string" || typeof first === "number") {
+      return first;
+    }
+  }
+  return void 0;
+}
+function mergeRouteValues(primaryValues, secondaryValues) {
+  const merged = {};
+  for (const [key, value] of Object.entries(secondaryValues ?? {})) {
+    const resolvedValue = readRouteValue(value);
+    if (resolvedValue !== void 0) {
+      merged[key] = resolvedValue;
+    }
+  }
+  for (const [key, value] of Object.entries(primaryValues ?? {})) {
+    const resolvedValue = readRouteValue(value);
+    if (resolvedValue !== void 0) {
+      merged[key] = resolvedValue;
+    }
+  }
+  return merged;
+}
+function templateSegmentKey(value) {
+  const matched = value.match(/^\{([a-zA-Z0-9_]+)\}$/);
+  return matched?.[1] ?? null;
+}
+function toPathSegments(path) {
+  if (typeof path !== "string" || path === "") {
+    return [];
+  }
+  let normalizedPath = path;
+  if (path.startsWith("http://") || path.startsWith("https://")) {
+    try {
+      normalizedPath = new URL(path).pathname;
+    } catch {
+      normalizedPath = path;
+    }
+  }
+  const withoutQueryOrHash = normalizedPath.split("#")[0]?.split("?")[0] ?? normalizedPath;
+  return withoutQueryOrHash.split("/").map((segment) => segment.trim()).filter((segment) => segment !== "").map((segment) => decodeURIComponent(segment));
+}
+function inferParamsFromPath(baseURLTemplate, currentPath) {
+  const inferred = {};
+  const templateSegments = toPathSegments(baseURLTemplate);
+  const currentSegments = toPathSegments(currentPath);
+  if (templateSegments.length === 0 || currentSegments.length === 0) {
+    return inferred;
+  }
+  for (let index = 0; index < templateSegments.length; index += 1) {
+    const templateSegment = templateSegments[index];
+    if (templateSegment === void 0) {
+      continue;
+    }
+    const key = templateSegmentKey(templateSegment);
+    if (key === null) {
+      continue;
+    }
+    let candidate;
+    const previousTemplate = templateSegments[index - 1];
+    const nextTemplate = templateSegments[index + 1];
+    const previousLiteral = previousTemplate !== void 0 && templateSegmentKey(previousTemplate) === null ? previousTemplate : void 0;
+    const nextLiteral = nextTemplate !== void 0 && templateSegmentKey(nextTemplate) === null ? nextTemplate : void 0;
+    if (previousLiteral !== void 0) {
+      for (let segmentIndex = 0; segmentIndex < currentSegments.length - 1; segmentIndex += 1) {
+        if (currentSegments[segmentIndex] === previousLiteral) {
+          candidate = currentSegments[segmentIndex + 1];
+          break;
+        }
+      }
+    }
+    if (candidate === void 0 && nextLiteral !== void 0) {
+      for (let segmentIndex = 1; segmentIndex < currentSegments.length; segmentIndex += 1) {
+        if (currentSegments[segmentIndex] === nextLiteral) {
+          candidate = currentSegments[segmentIndex - 1];
+          break;
+        }
+      }
+    }
+    if (candidate !== void 0 && candidate !== "") {
+      inferred[key] = candidate;
+    }
+  }
+  return inferred;
+}
+function withInferredMissingValues(base, inferred) {
+  const resolved = {
+    ...base
+  };
+  for (const [key, value] of Object.entries(inferred)) {
+    if (resolved[key] === void 0 || resolved[key] === "") {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+export default defineNuxtPlugin((nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  const route = useRoute();
+  const publicConfig = runtimeConfig.public.formforge;
+  const hookedNuxtApp = nuxtApp;
+  const routeParamsResolver = () => {
+    const appRouteQuery = hookedNuxtApp._route?.value?.query;
+    const appRouteParams = hookedNuxtApp._route?.value?.params;
+    const appRoutePath = hookedNuxtApp._route?.value?.path;
+    const composableRouteQuery = route.query;
+    const composableRouteParams = route.params;
+    const composableRoutePath = route.path;
+    const mergedRouteValues = mergeRouteValues(
+      {
+        ...composableRouteQuery,
+        ...composableRouteParams
+      },
+      {
+        ...appRouteQuery,
+        ...appRouteParams
+      }
+    );
+    const inferredFromPath = inferParamsFromPath(publicConfig?.baseURL, composableRoutePath || appRoutePath);
+    return withInferredMissingValues(mergedRouteValues, inferredFromPath);
+  };
+  const runtimeBaseURLParams = publicConfig?.baseURLParams;
+  const runtimeScopeParams = publicConfig?.scopeParams;
+  const resolvedBaseURLParams = (() => {
+    if (runtimeBaseURLParams === void 0) {
+      return routeParamsResolver;
+    }
+    if (typeof runtimeBaseURLParams === "function") {
+      return () => ({
+        ...routeParamsResolver(),
+        ...runtimeBaseURLParams()
+      });
+    }
+    return () => ({
+      ...routeParamsResolver(),
+      ...runtimeBaseURLParams
+    });
+  })();
+  const resolvedScopeParams = (() => {
+    if (runtimeScopeParams === void 0) {
+      return routeParamsResolver;
+    }
+    if (typeof runtimeScopeParams === "function") {
+      return () => ({
+        ...routeParamsResolver(),
+        ...runtimeScopeParams()
+      });
+    }
+    return () => ({
+      ...routeParamsResolver(),
+      ...runtimeScopeParams
+    });
+  })();
+  const client = createFormForgeClient({
+    ...publicConfig ?? {},
+    baseURLParams: resolvedBaseURLParams,
+    scopeParams: resolvedScopeParams,
+    beforeRequest: async (context) => {
+      await publicConfig?.beforeRequest?.(context);
+      await hookedNuxtApp.callHook("formforge:beforeRequest", context);
+    }
+  });
+  return {
+    provide: {
+      formforge: client
+    }
+  };
+});