@evanschleret/formforgeclient 1.0.0

package/dist/runtime/composables/useFormForgeCategory.js

@@ -0,0 +1,248 @@
+import { computed, ref } from "#imports";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+import { normalizeFormForgeCategoryOptions as normalizeCategoryOptions } from "../utils/category.js";
+function isFormForgeClientError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.status === "number" && typeof candidate.code === "string" && typeof candidate.message === "string";
+}
+function resolveErrorMessage(caughtError) {
+  if (caughtError instanceof Error) {
+    return caughtError.message;
+  }
+  return "Categories request failed";
+}
+export function useFormForgeCategory(options = {}) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const loading = ref(false);
+  const error = ref(null);
+  const clientError = ref(null);
+  const list = ref([]);
+  const current = ref(null);
+  const lastMeta = ref(void 0);
+  const lastLinks = ref(void 0);
+  const lastListQuery = ref(options.initialQuery ?? {});
+  const lastListEndpoint = ref(options.endpoint);
+  const lastListScope = ref(options.scope);
+  const lastCategoryKey = ref(null);
+  const lastMode = ref(null);
+  const immediateLoad = options.immediate ?? true;
+  const fieldErrors = computed(() => clientError.value?.fieldErrors ?? {});
+  const businessErrorCode = computed(() => clientError.value?.businessCode);
+  const isCategoryInUse = computed(() => businessErrorCode.value === "CATEGORY_IN_USE");
+  async function withLoading(callback) {
+    loading.value = true;
+    error.value = null;
+    clientError.value = null;
+    try {
+      return await callback();
+    } catch (caughtError) {
+      error.value = resolveErrorMessage(caughtError);
+      if (isFormForgeClientError(caughtError)) {
+        clientError.value = caughtError;
+      }
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function resolveEndpoint(requestOptions = {}) {
+    return requestOptions.endpoint ?? options.endpoint;
+  }
+  function resolveScope(requestOptions = {}) {
+    return requestOptions.scope ?? options.scope;
+  }
+  function withDefaultMutationOptions(mutationOptions = {}) {
+    return {
+      ...mutationOptions,
+      endpoint: mutationOptions.endpoint ?? options.endpoint,
+      scope: mutationOptions.scope ?? options.scope
+    };
+  }
+  async function listCategories(query = {}, requestOptions = {}) {
+    return withLoading(async () => {
+      const resolvedQuery = {
+        ...lastListQuery.value,
+        ...query
+      };
+      const endpoint = resolveEndpoint(requestOptions);
+      const scope = resolveScope(requestOptions);
+      const response = await client.listCategories(resolvedQuery, {
+        endpoint,
+        scope
+      });
+      list.value = response.data;
+      lastMeta.value = response.meta;
+      lastLinks.value = response.links;
+      lastListQuery.value = resolvedQuery;
+      lastListEndpoint.value = endpoint;
+      lastListScope.value = scope;
+      lastMode.value = "list";
+      return response;
+    });
+  }
+  async function getCategory(categoryKey, requestOptions = {}) {
+    return withLoading(async () => {
+      const response = await client.getCategory(categoryKey, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      current.value = response;
+      lastCategoryKey.value = categoryKey;
+      lastMode.value = "resource";
+      return response;
+    });
+  }
+  async function createCategory(input, options2 = {}) {
+    return withLoading(async () => {
+      const created = await client.createCategory(input, withDefaultMutationOptions(options2));
+      current.value = created;
+      list.value = [created, ...list.value.filter((item) => item.key !== created.key)];
+      return created;
+    });
+  }
+  async function patchCategory(categoryKey, input, options2 = {}) {
+    return withLoading(async () => {
+      const updated = await client.patchCategory(categoryKey, input, withDefaultMutationOptions(options2));
+      current.value = updated;
+      list.value = list.value.map((item) => item.key === updated.key ? updated : item);
+      return updated;
+    });
+  }
+  async function deleteCategory(categoryKey, options2 = {}) {
+    return withLoading(async () => {
+      const deleted = await client.deleteCategory(categoryKey, withDefaultMutationOptions(options2));
+      list.value = list.value.filter((item) => item.key !== categoryKey);
+      if (current.value?.key === categoryKey) {
+        current.value = null;
+      }
+      return deleted;
+    });
+  }
+  async function refresh(options2 = {}) {
+    const mode = options2.mode ?? "auto";
+    const endpoint = options2.endpoint ?? lastListEndpoint.value;
+    const scope = options2.scope ?? lastListScope.value;
+    if (mode === "list") {
+      return listCategories(options2.query ?? lastListQuery.value, {
+        endpoint,
+        scope
+      });
+    }
+    if (mode === "resource") {
+      const categoryKey = options2.categoryKey ?? lastCategoryKey.value;
+      if (typeof categoryKey === "string" && categoryKey !== "") {
+        return getCategory(categoryKey, {
+          endpoint,
+          scope
+        });
+      }
+      return listCategories(options2.query ?? lastListQuery.value, {
+        endpoint,
+        scope
+      });
+    }
+    if (lastMode.value === "resource") {
+      const categoryKey = options2.categoryKey ?? lastCategoryKey.value;
+      if (typeof categoryKey === "string" && categoryKey !== "") {
+        return getCategory(categoryKey, {
+          endpoint,
+          scope
+        });
+      }
+    }
+    return listCategories(options2.query ?? lastListQuery.value, {
+      endpoint,
+      scope
+    });
+  }
+  if (immediateLoad) {
+    listCategories(options.initialQuery, {
+      endpoint: options.endpoint,
+      scope: options.scope
+    }).catch(() => {
+    });
+  }
+  return {
+    client,
+    loading,
+    error,
+    clientError,
+    fieldErrors,
+    businessErrorCode,
+    isCategoryInUse,
+    list,
+    current,
+    lastMeta,
+    lastLinks,
+    lastListQuery,
+    lastListEndpoint,
+    lastListScope,
+    lastCategoryKey,
+    listCategories,
+    getCategory,
+    createCategory,
+    patchCategory,
+    deleteCategory,
+    refresh
+  };
+}
+function readCategorySourceValue(source) {
+  if (typeof source === "function") {
+    return source();
+  }
+  if (source !== null && typeof source === "object" && "value" in source) {
+    return source.value;
+  }
+  return source;
+}
+function pickCategoriesFromRecord(record, key) {
+  const candidateKeys = [key, "list", "categories", "data"];
+  for (const candidateKey of candidateKeys) {
+    const candidate = readCategorySourceValue(record[candidateKey]);
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+  const rawData = readCategorySourceValue(record.data);
+  if (rawData !== null && typeof rawData === "object") {
+    const nestedData = rawData.data;
+    const resolvedNestedData = readCategorySourceValue(nestedData);
+    if (Array.isArray(resolvedNestedData)) {
+      return resolvedNestedData;
+    }
+  }
+  return [];
+}
+function resolveHelperCategories(options) {
+  const source = options.source ?? options.categories;
+  const resolvedSource = readCategorySourceValue(source);
+  if (Array.isArray(resolvedSource)) {
+    return resolvedSource;
+  }
+  if (resolvedSource !== null && typeof resolvedSource === "object") {
+    const key = options.key ?? "list";
+    return pickCategoriesFromRecord(resolvedSource, key);
+  }
+  return [];
+}
+export function normalizeFormForgeCategoryOptions(categories, includeInactive = true) {
+  return normalizeCategoryOptions(categories, includeInactive);
+}
+export function useFormForgeCategoryOptions(options = {}) {
+  const hasExplicitSource = options.source !== void 0 || options.categories !== void 0;
+  const categoryLoader = hasExplicitSource ? null : useFormForgeCategory({
+    immediate: options.immediate ?? true,
+    initialQuery: options.query,
+    endpoint: options.endpoint,
+    scope: options.scope,
+    client: options.client,
+    clientConfig: options.clientConfig
+  });
+  return computed(() => {
+    const categories = hasExplicitSource ? resolveHelperCategories(options) : categoryLoader?.list.value ?? [];
+    return normalizeFormForgeCategoryOptions(categories, options.includeInactive ?? true);
+  });
+}

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

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

package/dist/runtime/composables/useFormForgeClient.js

@@ -0,0 +1,200 @@
+import { useNuxtApp, useRoute, useRuntimeConfig } from "#imports";
+import { createFormForgeClient } from "../api/index.js";
+function hasConfigOverrides(config) {
+  return Object.keys(config).length > 0;
+}
+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 function useFormForgeClient(config = {}) {
+  const nuxtApp = useNuxtApp();
+  const route = useRoute();
+  const injectedClient = nuxtApp.$formforge;
+  if (injectedClient !== void 0 && !hasConfigOverrides(config)) {
+    return injectedClient;
+  }
+  const runtimeConfig = useRuntimeConfig();
+  const runtimePublicConfig = runtimeConfig.public.formforge;
+  const routeParamsResolver = () => {
+    const appRouteQuery = nuxtApp._route?.value?.query;
+    const appRouteParams = nuxtApp._route?.value?.params;
+    const appRoutePath = nuxtApp._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(config.baseURL ?? runtimePublicConfig?.baseURL, composableRoutePath || appRoutePath);
+    return withInferredMissingValues(mergedRouteValues, inferredFromPath);
+  };
+  const baseConfig = runtimePublicConfig;
+  const mergedConfig = {
+    ...baseConfig,
+    ...config
+  };
+  const configBaseURLParams = config.baseURLParams;
+  const runtimeBaseURLParams = baseConfig?.baseURLParams;
+  const configScopeParams = config.scopeParams;
+  const runtimeScopeParams = baseConfig?.scopeParams;
+  if (configBaseURLParams !== void 0) {
+    if (typeof configBaseURLParams === "function") {
+      mergedConfig.baseURLParams = () => ({
+        ...routeParamsResolver(),
+        ...configBaseURLParams()
+      });
+    } else {
+      mergedConfig.baseURLParams = () => ({
+        ...routeParamsResolver(),
+        ...configBaseURLParams
+      });
+    }
+  } else if (runtimeBaseURLParams !== void 0) {
+    if (typeof runtimeBaseURLParams === "function") {
+      mergedConfig.baseURLParams = () => ({
+        ...routeParamsResolver(),
+        ...runtimeBaseURLParams()
+      });
+    } else {
+      mergedConfig.baseURLParams = () => ({
+        ...routeParamsResolver(),
+        ...runtimeBaseURLParams
+      });
+    }
+  } else {
+    mergedConfig.baseURLParams = routeParamsResolver;
+  }
+  if (configScopeParams !== void 0) {
+    if (typeof configScopeParams === "function") {
+      mergedConfig.scopeParams = () => ({
+        ...routeParamsResolver(),
+        ...configScopeParams()
+      });
+    } else {
+      mergedConfig.scopeParams = () => ({
+        ...routeParamsResolver(),
+        ...configScopeParams
+      });
+    }
+  } else if (runtimeScopeParams !== void 0) {
+    if (typeof runtimeScopeParams === "function") {
+      mergedConfig.scopeParams = () => ({
+        ...routeParamsResolver(),
+        ...runtimeScopeParams()
+      });
+    } else {
+      mergedConfig.scopeParams = () => ({
+        ...routeParamsResolver(),
+        ...runtimeScopeParams
+      });
+    }
+  } else {
+    mergedConfig.scopeParams = routeParamsResolver;
+  }
+  return createFormForgeClient(mergedConfig);
+}

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

@@ -0,0 +1,20 @@
+import type { FormForgeRequestOptions } from '../api/request.js';
+import type { FormForgeClient, FormForgeClientConfig, FormForgeDraftRecord, FormForgeJsonObject, FormForgeScope, FormForgeSubmissionPayload } from '../types/index.js';
+export interface UseFormForgeDraftsOptions {
+    key: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export type FormForgeDraftRequestOptions = FormForgeRequestOptions;
+export declare function useFormForgeDrafts(options: UseFormForgeDraftsOptions): {
+    client: FormForgeClient;
+    loading: any;
+    error: any;
+    draft: any;
+    saveDraft: (payload: FormForgeSubmissionPayload, meta?: FormForgeJsonObject, requestOptions?: FormForgeDraftRequestOptions) => Promise<FormForgeDraftRecord | null>;
+    fetchCurrentDraft: (requestOptions?: FormForgeDraftRequestOptions) => Promise<FormForgeDraftRecord | null>;
+    deleteCurrentDraft: (requestOptions?: FormForgeDraftRequestOptions) => Promise<FormForgeDraftRecord | null>;
+};
+//# sourceMappingURL=useFormForgeDrafts.d.ts.map

package/dist/runtime/composables/useFormForgeDrafts.js

@@ -0,0 +1,78 @@
+import { ref } from "#imports";
+import { toFormForgeJsonSubmissionPayload } from "../utils/submission.js";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+export function useFormForgeDrafts(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const loading = ref(false);
+  const error = ref(null);
+  const draft = ref(null);
+  function resolveEndpoint(requestOptions = {}) {
+    return requestOptions.endpoint ?? options.endpoint;
+  }
+  function resolveScope(requestOptions = {}) {
+    return requestOptions.scope ?? options.scope;
+  }
+  async function saveDraft(payload, meta, requestOptions = {}) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const response = await client.saveDraft(options.key, {
+        payload: toFormForgeJsonSubmissionPayload(payload),
+        meta
+      }, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      draft.value = response.data;
+      return response.data;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to save draft";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function fetchCurrentDraft(requestOptions = {}) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const response = await client.getCurrentDraft(options.key, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      draft.value = response.data;
+      return response.data;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to fetch draft";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function deleteCurrentDraft(requestOptions = {}) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const response = await client.deleteCurrentDraft(options.key, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      draft.value = response.data;
+      return response.data;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to delete draft";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    client,
+    loading,
+    error,
+    draft,
+    saveDraft,
+    fetchCurrentDraft,
+    deleteCurrentDraft
+  };
+}

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

@@ -0,0 +1,26 @@
+import type { FormForgeClient, FormForgeClientConfig, FormForgeFormSchema, FormForgeScope, FormForgeSubmissionPayload } from '../types/index.js';
+import type { FormForgeRequestOptions } from '../api/request.js';
+export interface UseFormForgeFormOptions {
+    key: string;
+    version?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    immediate?: boolean;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export type FormForgeFormRequestOptions = FormForgeRequestOptions;
+export declare function useFormForgeForm(options: UseFormForgeFormOptions): {
+    client: FormForgeClient;
+    schema: any;
+    state: any;
+    loading: any;
+    initialized: any;
+    error: any;
+    zodSchema: any;
+    fetchSchema: (requestOptions?: FormForgeFormRequestOptions) => Promise<FormForgeFormSchema>;
+    resetState: () => void;
+    setFieldValue: (fieldName: string, value: FormForgeSubmissionPayload[string]) => void;
+    replaceState: (payload: FormForgeSubmissionPayload) => void;
+};
+//# sourceMappingURL=useFormForgeForm.d.ts.map

package/dist/runtime/composables/useFormForgeForm.js

@@ -0,0 +1,114 @@
+import { ref } from "#imports";
+import { createFormForgeZodSchema } from "../validation/zod.js";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+function clonePayload(payload) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(payload);
+    } catch {
+      return {
+        ...payload
+      };
+    }
+  }
+  return {
+    ...payload
+  };
+}
+function createInitialPayload(schema) {
+  const payload = {};
+  for (const field of schema.fields) {
+    if (field.default !== void 0) {
+      payload[field.name] = field.default;
+      continue;
+    }
+    if (field.type === "checkbox" || field.type === "switch") {
+      payload[field.name] = false;
+      continue;
+    }
+    if (field.type === "checkbox_group") {
+      payload[field.name] = [];
+      continue;
+    }
+    if (field.type === "date_range" || field.type === "datetime_range") {
+      payload[field.name] = {
+        start: null,
+        end: null
+      };
+      continue;
+    }
+    payload[field.name] = null;
+  }
+  return payload;
+}
+export function useFormForgeForm(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const schema = ref(null);
+  const state = ref({});
+  const initialState = ref({});
+  const loading = ref(false);
+  const initialized = ref(false);
+  const lastError = ref(null);
+  const zodSchema = ref(void 0);
+  function resolveEndpoint(requestOptions = {}) {
+    return requestOptions.endpoint ?? options.endpoint;
+  }
+  function resolveScope(requestOptions = {}) {
+    return requestOptions.scope ?? options.scope;
+  }
+  async function fetchSchema(requestOptions = {}) {
+    loading.value = true;
+    lastError.value = null;
+    try {
+      const endpoint = resolveEndpoint(requestOptions);
+      const scope = resolveScope(requestOptions);
+      const nextSchema = options.version !== void 0 && options.version !== "" ? await client.getFormVersion(options.key, options.version, { endpoint, scope }) : await client.getForm(options.key, { endpoint, scope });
+      const nextState = createInitialPayload(nextSchema);
+      schema.value = nextSchema;
+      initialState.value = nextState;
+      state.value = clonePayload(nextState);
+      zodSchema.value = createFormForgeZodSchema(nextSchema);
+      initialized.value = true;
+      return nextSchema;
+    } catch (error) {
+      lastError.value = error instanceof Error ? error.message : "Failed to load form schema";
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function resetState() {
+    if (schema.value === null) {
+      state.value = {};
+      initialState.value = {};
+      return;
+    }
+    state.value = clonePayload(initialState.value);
+  }
+  function setFieldValue(fieldName, value) {
+    state.value = {
+      ...state.value,
+      [fieldName]: value
+    };
+  }
+  function replaceState(payload) {
+    state.value = clonePayload(payload);
+  }
+  if (options.immediate !== false) {
+    fetchSchema().catch(() => {
+    });
+  }
+  return {
+    client,
+    schema,
+    state,
+    loading,
+    initialized,
+    error: lastError,
+    zodSchema,
+    fetchSchema,
+    resetState,
+    setFieldValue,
+    replaceState
+  };
+}