@evanschleret/formforgeclient 1.0.0

package/dist/runtime/api/client.js

@@ -0,0 +1,148 @@
+import { createFormForgeHttpAdapter } from "./http.js";
+import { deleteCurrentFormForgeDraft, fetchCurrentFormForgeDraft, saveFormForgeDraft } from "./drafts.js";
+import { fetchFormForgeDiff, fetchFormForgeForms, fetchFormForgeRevisions, createFormForgeForm, deleteFormForgeForm, patchFormForgeForm, publishFormForgeForm, unpublishFormForgeForm } from "./management.js";
+import { createFormForgeCategory, deleteFormForgeCategory, fetchFormForgeCategories, fetchFormForgeCategory, patchFormForgeCategory } from "./categories.js";
+import { fetchFormForgeSchema, fetchFormForgeSchemaVersion, fetchFormForgeSchemaVersions, resolveFormForgeSchema } from "./schema.js";
+import { deleteFormForgeResponse, fetchFormForgeResponse, fetchFormForgeResponses } from "./responses.js";
+import { submitFormForgeJson, submitFormForgeMultipart } from "./submission.js";
+import { stageFormForgeUpload } from "./upload.js";
+class FormForgeClientImpl {
+  config;
+  http;
+  constructor(config = {}) {
+    this.config = {
+      ...config
+    };
+    this.http = createFormForgeHttpAdapter(this.config);
+  }
+  resolveScopeParams(input) {
+    if (input === void 0) {
+      return {};
+    }
+    if (typeof input === "function") {
+      return input();
+    }
+    return input;
+  }
+  resolveNamedScope(name) {
+    const scopedRoutes = this.config.scopedRoutes ?? {};
+    const routeDefinition = scopedRoutes[name];
+    if (routeDefinition === void 0) {
+      throw new Error(`Unknown FormForge scope "${name}"`);
+    }
+    const sourceParams = this.resolveScopeParams(this.config.scopeParams);
+    const params = {};
+    for (const [scopeParam, sourceParam] of Object.entries(routeDefinition.paramsFromRoute)) {
+      const value = sourceParams[sourceParam];
+      if (value === void 0 || value === "") {
+        throw new Error(`Missing scope param source "${sourceParam}" for named scope "${name}"`);
+      }
+      params[scopeParam] = value;
+    }
+    return {
+      prefix: routeDefinition.prefix,
+      params
+    };
+  }
+  resolveRequestScope(scope) {
+    const targetScope = scope ?? this.config.defaultScope;
+    if (targetScope === void 0) {
+      return void 0;
+    }
+    if (typeof targetScope === "string") {
+      return this.resolveNamedScope(targetScope);
+    }
+    return targetScope;
+  }
+  withRequestScope(options) {
+    const resolvedScope = this.resolveRequestScope(options.scope);
+    if (resolvedScope === void 0) {
+      return options;
+    }
+    return {
+      ...options,
+      scope: resolvedScope
+    };
+  }
+  async getForm(key, options = {}) {
+    return fetchFormForgeSchema(this.http, key, this.withRequestScope(options));
+  }
+  async getFormVersions(key, options = {}) {
+    return fetchFormForgeSchemaVersions(this.http, key, this.withRequestScope(options));
+  }
+  async getFormVersion(key, version, options = {}) {
+    return fetchFormForgeSchemaVersion(this.http, key, version, this.withRequestScope(options));
+  }
+  async resolveForm(key, input = {}, options = {}) {
+    return resolveFormForgeSchema(this.http, key, input, options.version, this.withRequestScope(options));
+  }
+  async submitForm(key, input, options = {}) {
+    return submitFormForgeJson(this.http, key, input, this.withRequestScope(options));
+  }
+  async submitFormMultipart(key, formData, options = {}) {
+    return submitFormForgeMultipart(this.http, key, formData, this.withRequestScope(options));
+  }
+  async stageUpload(key, input, options = {}) {
+    return stageFormForgeUpload(this.http, key, input, this.withRequestScope(options));
+  }
+  async saveDraft(key, input, options = {}) {
+    return saveFormForgeDraft(this.http, key, input, this.withRequestScope(options));
+  }
+  async getCurrentDraft(key, options = {}) {
+    return fetchCurrentFormForgeDraft(this.http, key, this.withRequestScope(options));
+  }
+  async deleteCurrentDraft(key, options = {}) {
+    return deleteCurrentFormForgeDraft(this.http, key, this.withRequestScope(options));
+  }
+  async listResponses(key, query = {}, options = {}) {
+    return fetchFormForgeResponses(this.http, key, query, this.withRequestScope(options));
+  }
+  async getResponse(key, submissionId, options = {}) {
+    return fetchFormForgeResponse(this.http, key, submissionId, this.withRequestScope(options));
+  }
+  async deleteResponse(key, submissionId, options = {}) {
+    return deleteFormForgeResponse(this.http, key, submissionId, this.withRequestScope(options));
+  }
+  async listForms(includeDeleted = false, options = {}) {
+    return fetchFormForgeForms(this.http, includeDeleted, this.withRequestScope(options));
+  }
+  async createForm(input, options = {}) {
+    return createFormForgeForm(this.http, input, this.withRequestScope(options));
+  }
+  async patchForm(key, input, options = {}) {
+    return patchFormForgeForm(this.http, key, input, this.withRequestScope(options));
+  }
+  async publishForm(key, options = {}) {
+    return publishFormForgeForm(this.http, key, this.withRequestScope(options));
+  }
+  async unpublishForm(key, options = {}) {
+    return unpublishFormForgeForm(this.http, key, this.withRequestScope(options));
+  }
+  async deleteForm(key, options = {}) {
+    return deleteFormForgeForm(this.http, key, this.withRequestScope(options));
+  }
+  async getRevisions(key, includeDeleted = false, options = {}) {
+    return fetchFormForgeRevisions(this.http, key, includeDeleted, this.withRequestScope(options));
+  }
+  async getDiff(key, fromVersion, toVersion, options = {}) {
+    return fetchFormForgeDiff(this.http, key, fromVersion, toVersion, this.withRequestScope(options));
+  }
+  async listCategories(query = {}, options = {}) {
+    return fetchFormForgeCategories(this.http, query, this.withRequestScope(options));
+  }
+  async getCategory(categoryKey, options = {}) {
+    return fetchFormForgeCategory(this.http, categoryKey, this.withRequestScope(options));
+  }
+  async createCategory(input, options = {}) {
+    return createFormForgeCategory(this.http, input, this.withRequestScope(options));
+  }
+  async patchCategory(categoryKey, input, options = {}) {
+    return patchFormForgeCategory(this.http, categoryKey, input, this.withRequestScope(options));
+  }
+  async deleteCategory(categoryKey, options = {}) {
+    return deleteFormForgeCategory(this.http, categoryKey, this.withRequestScope(options));
+  }
+}
+export function createFormForgeClient(config = {}) {
+  return new FormForgeClientImpl(config);
+}

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

@@ -0,0 +1,6 @@
+import type { FormForgeDraftResponse, FormForgeDraftSaveInput, FormForgeHttpAdapter } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+export declare function saveFormForgeDraft(http: FormForgeHttpAdapter, key: string, input: FormForgeDraftSaveInput, options?: FormForgeRequestOptions): Promise<FormForgeDraftResponse>;
+export declare function fetchCurrentFormForgeDraft(http: FormForgeHttpAdapter, key: string, options?: FormForgeRequestOptions): Promise<FormForgeDraftResponse>;
+export declare function deleteCurrentFormForgeDraft(http: FormForgeHttpAdapter, key: string, options?: FormForgeRequestOptions): Promise<FormForgeDraftResponse>;
+//# sourceMappingURL=drafts.d.ts.map

package/dist/runtime/api/drafts.js

@@ -0,0 +1,77 @@
+import { isFormForgeJsonObject } from "../utils/object.js";
+import { resolveEndpointPath } from "./request.js";
+function pickNullableDataEnvelope(payload) {
+  const dataValue = payload.data;
+  if (dataValue === null) {
+    return null;
+  }
+  if (isFormForgeJsonObject(dataValue)) {
+    return dataValue;
+  }
+  return payload;
+}
+function toDraftRecord(value) {
+  if (value === null) {
+    return null;
+  }
+  const payloadValue = value.payload;
+  const payload = isFormForgeJsonObject(payloadValue) ? payloadValue : {};
+  const metaValue = value.meta;
+  const meta = isFormForgeJsonObject(metaValue) ? metaValue : void 0;
+  const ownerIdValue = value.owner_id;
+  const ownerId = typeof ownerIdValue === "string" || typeof ownerIdValue === "number" || ownerIdValue === null ? ownerIdValue : void 0;
+  return {
+    form_key: typeof value.form_key === "string" ? value.form_key : "",
+    form_version: typeof value.form_version === "string" ? value.form_version : void 0,
+    owner_type: typeof value.owner_type === "string" ? value.owner_type : void 0,
+    owner_id: ownerId,
+    payload,
+    meta,
+    expires_at: typeof value.expires_at === "string" || value.expires_at === null ? value.expires_at : void 0,
+    created_at: typeof value.created_at === "string" ? value.created_at : void 0,
+    updated_at: typeof value.updated_at === "string" ? value.updated_at : void 0
+  };
+}
+export async function saveFormForgeDraft(http, key, input, options = {}) {
+  const body = {
+    payload: JSON.parse(JSON.stringify(input.payload))
+  };
+  if (input.meta !== void 0) {
+    body.meta = input.meta;
+  }
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/drafts`, {
+      key
+    }, options.scope),
+    method: "POST",
+    json: body
+  });
+  return {
+    data: toDraftRecord(pickNullableDataEnvelope(response.data)),
+    meta: isFormForgeJsonObject(response.data.meta) ? response.data.meta : void 0
+  };
+}
+export async function fetchCurrentFormForgeDraft(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/drafts/current`, {
+      key
+    }, options.scope),
+    method: "GET"
+  });
+  return {
+    data: toDraftRecord(pickNullableDataEnvelope(response.data)),
+    meta: isFormForgeJsonObject(response.data.meta) ? response.data.meta : void 0
+  };
+}
+export async function deleteCurrentFormForgeDraft(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/drafts/current`, {
+      key
+    }, options.scope),
+    method: "DELETE"
+  });
+  return {
+    data: toDraftRecord(pickNullableDataEnvelope(response.data)),
+    meta: isFormForgeJsonObject(response.data.meta) ? response.data.meta : void 0
+  };
+}

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

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

package/dist/runtime/api/http.js

@@ -0,0 +1,138 @@
+import { normalizeFormForgeClientError, normalizeNetworkFormForgeError } from "../validation/errors.js";
+import { isFormForgeJsonObject } from "../utils/object.js";
+function normalizeBaseUrl(baseURL) {
+  if (baseURL === void 0 || baseURL === "") {
+    return "/api/formforge/v1";
+  }
+  if (baseURL.endsWith("/")) {
+    return baseURL.slice(0, -1);
+  }
+  return baseURL;
+}
+function resolveBaseURLParams(input) {
+  if (input === void 0) {
+    return {};
+  }
+  if (typeof input === "function") {
+    return input();
+  }
+  return input;
+}
+function resolveBaseURL(baseURLTemplate, paramsInput) {
+  if (!baseURLTemplate.includes("{")) {
+    return baseURLTemplate;
+  }
+  const params = resolveBaseURLParams(paramsInput);
+  return baseURLTemplate.replaceAll(/\{([a-zA-Z0-9_]+)\}/g, (token, key) => {
+    const value = params[key];
+    if (value === void 0 || value === "") {
+      return token;
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function normalizePath(path) {
+  if (path.startsWith("/")) {
+    return path;
+  }
+  return `/${path}`;
+}
+function appendQuery(path, query) {
+  if (query === void 0) {
+    return path;
+  }
+  const queryParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    queryParams.set(key, String(value));
+  }
+  const rawQuery = queryParams.toString();
+  if (rawQuery.length === 0) {
+    return path;
+  }
+  return `${path}?${rawQuery}`;
+}
+function toJsonPayload(text) {
+  if (text.length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function parseResponsePayload(response) {
+  if (response.status === 204) {
+    return null;
+  }
+  const text = await response.text();
+  const jsonPayload = toJsonPayload(text);
+  if (isFormForgeJsonObject(jsonPayload)) {
+    return jsonPayload;
+  }
+  if (text.length > 0) {
+    return {
+      message: text
+    };
+  }
+  return null;
+}
+async function runBeforeRequest(callback, request, headers, url) {
+  if (callback === void 0) {
+    return;
+  }
+  const context = {
+    request,
+    headers,
+    url
+  };
+  await callback(context);
+}
+export function createFormForgeHttpAdapter(config = {}) {
+  const baseURLTemplate = normalizeBaseUrl(config.baseURL);
+  const fetchImpl = config.fetch ?? fetch;
+  const defaultHeaders = {
+    Accept: "application/json",
+    ...config.headers ?? {}
+  };
+  const credentials = config.credentials ?? "include";
+  return async function formForgeHttpAdapter(request) {
+    const endpointPath = normalizePath(request.path);
+    const resolvedBaseURL = resolveBaseURL(baseURLTemplate, config.baseURLParams);
+    const targetPath = appendQuery(`${resolvedBaseURL}${endpointPath}`, request.query);
+    const headers = {
+      ...defaultHeaders,
+      ...request.headers ?? {}
+    };
+    let body = request.body;
+    if (request.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(request.json);
+    }
+    await runBeforeRequest(config.beforeRequest, request, headers, targetPath);
+    let response;
+    try {
+      response = await fetchImpl(targetPath, {
+        method: request.method,
+        headers,
+        credentials,
+        body
+      });
+    } catch {
+      throw normalizeNetworkFormForgeError("Network request failed");
+    }
+    const payload = await parseResponsePayload(response);
+    if (!response.ok) {
+      throw normalizeFormForgeClientError(response.status, payload);
+    }
+    const data = payload ?? {};
+    return {
+      status: response.status,
+      headers: response.headers,
+      data
+    };
+  };
+}

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

@@ -0,0 +1,9 @@
+export { createFormForgeClient } from './client.js';
+export { resolveFormForgeSchema, fetchFormForgeSchema, fetchFormForgeSchemaVersion, fetchFormForgeSchemaVersions } from './schema.js';
+export { saveFormForgeDraft, fetchCurrentFormForgeDraft, deleteCurrentFormForgeDraft } from './drafts.js';
+export { fetchFormForgeResponses, fetchFormForgeResponse, deleteFormForgeResponse } from './responses.js';
+export { fetchFormForgeCategories, fetchFormForgeCategory, createFormForgeCategory, patchFormForgeCategory, deleteFormForgeCategory } from './categories.js';
+export type { FormForgeClient, FormForgeSubmitRequestOptions, FormForgeSubmitMultipartOptions } from './client.js';
+export type { FormForgeMutationOptions, FormForgeManagementRequestOptions } from './management.js';
+export type { FormForgeRequestOptions } from './request.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/index.js

@@ -0,0 +1,11 @@
+export { createFormForgeClient } from "./client.js";
+export { resolveFormForgeSchema, fetchFormForgeSchema, fetchFormForgeSchemaVersion, fetchFormForgeSchemaVersions } from "./schema.js";
+export { saveFormForgeDraft, fetchCurrentFormForgeDraft, deleteCurrentFormForgeDraft } from "./drafts.js";
+export { fetchFormForgeResponses, fetchFormForgeResponse, deleteFormForgeResponse } from "./responses.js";
+export {
+  fetchFormForgeCategories,
+  fetchFormForgeCategory,
+  createFormForgeCategory,
+  patchFormForgeCategory,
+  deleteFormForgeCategory
+} from "./categories.js";

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

@@ -0,0 +1,19 @@
+import type { FormForgeDiffResponse, FormForgeHttpAdapter, FormForgeManagementCreateInput, FormForgeManagementForm, FormForgeManagementPatchInput, FormForgeRevisionSummary } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+export interface FormForgeMutationOptions extends FormForgeRequestOptions {
+    idempotencyKey?: string;
+}
+export type FormForgeManagementFilterValue = string | number | boolean | undefined;
+export type FormForgeManagementFilters = Record<string, FormForgeManagementFilterValue>;
+export interface FormForgeManagementRequestOptions extends FormForgeRequestOptions {
+    filters?: FormForgeManagementFilters;
+}
+export declare function createFormForgeForm(http: FormForgeHttpAdapter, input: FormForgeManagementCreateInput, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+export declare function fetchFormForgeForms(http: FormForgeHttpAdapter, includeDeleted?: boolean, options?: FormForgeManagementRequestOptions): Promise<FormForgeManagementForm[]>;
+export declare function patchFormForgeForm(http: FormForgeHttpAdapter, key: string, input: FormForgeManagementPatchInput, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+export declare function publishFormForgeForm(http: FormForgeHttpAdapter, key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+export declare function unpublishFormForgeForm(http: FormForgeHttpAdapter, key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+export declare function deleteFormForgeForm(http: FormForgeHttpAdapter, key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+export declare function fetchFormForgeRevisions(http: FormForgeHttpAdapter, key: string, includeDeleted?: boolean, options?: FormForgeManagementRequestOptions): Promise<FormForgeRevisionSummary[]>;
+export declare function fetchFormForgeDiff(http: FormForgeHttpAdapter, key: string, fromVersion: number, toVersion: number, options?: FormForgeManagementRequestOptions): Promise<FormForgeDiffResponse>;
+//# sourceMappingURL=management.d.ts.map

package/dist/runtime/api/management.js

@@ -0,0 +1,180 @@
+import { isFormForgeJsonObject, pickFormForgeDataEnvelope } from "../utils/object.js";
+import { normalizeFormForgeCategory } from "../utils/category.js";
+import { resolveEndpointPath } from "./request.js";
+function normalizeManagementForm(value) {
+  if (!isFormForgeJsonObject(value)) {
+    return null;
+  }
+  const rawValue = value;
+  const category = typeof rawValue.category === "string" || rawValue.category === null ? rawValue.category : void 0;
+  const rawCategoryItem = rawValue.category_item;
+  const categoryItem = rawCategoryItem === null ? null : normalizeFormForgeCategory(rawCategoryItem);
+  const normalized = {
+    ...rawValue
+  };
+  if (category !== void 0) {
+    normalized.category = category;
+  }
+  if (rawCategoryItem === null || categoryItem !== null) {
+    normalized.category_item = categoryItem;
+  }
+  return normalized;
+}
+function asManagementFormArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const items = [];
+  for (const item of value) {
+    const normalized = normalizeManagementForm(item);
+    if (normalized !== null) {
+      items.push(normalized);
+    }
+  }
+  return items;
+}
+function normalizeFormsList(payload) {
+  const dataValue = payload.data;
+  if (Array.isArray(dataValue)) {
+    return asManagementFormArray(dataValue);
+  }
+  if (!isFormForgeJsonObject(dataValue)) {
+    return asManagementFormArray(payload.items ?? payload.forms);
+  }
+  const nestedData = dataValue.data;
+  if (Array.isArray(nestedData)) {
+    return asManagementFormArray(nestedData);
+  }
+  return asManagementFormArray(dataValue.items ?? dataValue.forms);
+}
+function withMutationHeaders(options = {}) {
+  if (options.idempotencyKey === void 0 || options.idempotencyKey === "") {
+    return {};
+  }
+  return {
+    "Idempotency-Key": options.idempotencyKey
+  };
+}
+function toJsonObject(input) {
+  return JSON.parse(JSON.stringify(input));
+}
+export async function createFormForgeForm(http, input, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, "/forms", {}, options.scope),
+    method: "POST",
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  });
+  return normalizeManagementForm(pickFormForgeDataEnvelope(response.data)) ?? {};
+}
+export async function fetchFormForgeForms(http, includeDeleted = false, options = {}) {
+  const filters = options.filters ?? {};
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, "/forms", {}, options.scope),
+    method: "GET",
+    query: {
+      ...filters,
+      include_deleted: includeDeleted ? 1 : 0
+    }
+  });
+  return normalizeFormsList(response.data);
+}
+export async function patchFormForgeForm(http, key, input, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}`, {
+      key
+    }, options.scope),
+    method: "PATCH",
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  });
+  return normalizeManagementForm(pickFormForgeDataEnvelope(response.data)) ?? {};
+}
+export async function publishFormForgeForm(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/publish`, {
+      key
+    }, options.scope),
+    method: "POST",
+    headers: withMutationHeaders(options)
+  });
+  return normalizeManagementForm(pickFormForgeDataEnvelope(response.data)) ?? {};
+}
+export async function unpublishFormForgeForm(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/unpublish`, {
+      key
+    }, options.scope),
+    method: "POST",
+    headers: withMutationHeaders(options)
+  });
+  return normalizeManagementForm(pickFormForgeDataEnvelope(response.data)) ?? {};
+}
+export async function deleteFormForgeForm(http, key, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}`, {
+      key
+    }, options.scope),
+    method: "DELETE",
+    headers: withMutationHeaders(options)
+  });
+  return normalizeManagementForm(pickFormForgeDataEnvelope(response.data)) ?? {};
+}
+export async function fetchFormForgeRevisions(http, key, includeDeleted = false, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/revisions`, {
+      key
+    }, options.scope),
+    method: "GET",
+    query: {
+      include_deleted: includeDeleted ? 1 : 0
+    }
+  });
+  const dataEnvelope = pickFormForgeDataEnvelope(response.data);
+  const revisionsValue = dataEnvelope.revisions ?? dataEnvelope.data ?? dataEnvelope.items;
+  if (!Array.isArray(revisionsValue)) {
+    return [];
+  }
+  const revisions = [];
+  for (const item of revisionsValue) {
+    if (!isFormForgeJsonObject(item)) {
+      continue;
+    }
+    const revisionId = typeof item.revision_id === "string" ? item.revision_id : "";
+    const versionNumber = typeof item.version_number === "number" ? item.version_number : 0;
+    const isPublished = typeof item.is_published === "boolean" ? item.is_published : false;
+    revisions.push({
+      revision_id: revisionId,
+      version_number: versionNumber,
+      is_published: isPublished,
+      created_at: typeof item.created_at === "string" ? item.created_at : void 0,
+      deleted_at: typeof item.deleted_at === "string" || item.deleted_at === null ? item.deleted_at : void 0
+    });
+  }
+  return revisions;
+}
+export async function fetchFormForgeDiff(http, key, fromVersion, toVersion, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/forms/${key}/diff/${fromVersion}/${toVersion}`, {
+      key,
+      fromVersion,
+      toVersion
+    }, options.scope),
+    method: "GET"
+  });
+  const dataEnvelope = pickFormForgeDataEnvelope(response.data);
+  const changesValue = dataEnvelope.changes;
+  const changes = [];
+  if (Array.isArray(changesValue)) {
+    for (const item of changesValue) {
+      if (isFormForgeJsonObject(item)) {
+        changes.push(item);
+      }
+    }
+  }
+  return {
+    from_version: typeof dataEnvelope.from_version === "number" ? dataEnvelope.from_version : fromVersion,
+    to_version: typeof dataEnvelope.to_version === "number" ? dataEnvelope.to_version : toVersion,
+    changes
+  };
+}

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

@@ -0,0 +1,8 @@
+import type { FormForgeScope } from '../types/index.js';
+export interface FormForgeRequestOptions {
+    endpoint?: string;
+    scope?: FormForgeScope;
+}
+export declare function applyFormForgeScope(path: string, scope: FormForgeScope | undefined): string;
+export declare function resolveEndpointPath(endpoint: string | undefined, fallback: string, params?: Record<string, string | number>, scope?: FormForgeScope | undefined): string;
+//# sourceMappingURL=request.d.ts.map

package/dist/runtime/api/request.js

@@ -0,0 +1,52 @@
+const TEMPLATE_PARAM_PATTERN = /\{([a-zA-Z0-9_]+)(?::[^}]+)?\}/g;
+function normalizePath(path) {
+  if (path.startsWith("/")) {
+    return path;
+  }
+  return `/${path}`;
+}
+function stripWrappingSlashes(value) {
+  return value.replaceAll(/^\/+|\/+$/g, "");
+}
+function replaceTemplateParams(template, params, strict, context) {
+  return template.replaceAll(TEMPLATE_PARAM_PATTERN, (token, key) => {
+    const value = params[key];
+    if (value === void 0 || value === "") {
+      if (strict) {
+        throw new Error(`Missing required scope param "${key}" for scope prefix "${context ?? template}"`);
+      }
+      return token;
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function resolveScopeInput(scope) {
+  if (scope === void 0) {
+    return void 0;
+  }
+  if (typeof scope === "string") {
+    throw new Error(`Named scope "${scope}" is not resolved. Use createFormForgeClient with scopedRoutes/defaultScope or pass a scope object.`);
+  }
+  return scope;
+}
+export function applyFormForgeScope(path, scope) {
+  const resolvedScope = resolveScopeInput(scope);
+  const normalizedPath = normalizePath(path);
+  if (resolvedScope === void 0) {
+    return normalizedPath;
+  }
+  const trimmedPrefix = stripWrappingSlashes(resolvedScope.prefix);
+  if (trimmedPrefix === "") {
+    return normalizedPath;
+  }
+  const resolvedPrefix = replaceTemplateParams(trimmedPrefix, resolvedScope.params, true, resolvedScope.prefix);
+  if (normalizedPath === "/") {
+    return `/${resolvedPrefix}`;
+  }
+  return `/${resolvedPrefix}${normalizedPath}`;
+}
+export function resolveEndpointPath(endpoint, fallback, params = {}, scope = void 0) {
+  const template = typeof endpoint === "string" && endpoint !== "" ? endpoint : fallback;
+  const resolvedPath = replaceTemplateParams(template, params, false);
+  return applyFormForgeScope(resolvedPath, scope);
+}

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

@@ -0,0 +1,6 @@
+import type { FormForgeHttpAdapter, FormForgeJsonObject, FormForgeResponsesListResponse } from '../types/index.js';
+import { type FormForgeRequestOptions } from './request.js';
+export declare function fetchFormForgeResponses(http: FormForgeHttpAdapter, key: string, query?: Record<string, string | number | boolean | undefined>, options?: FormForgeRequestOptions): Promise<FormForgeResponsesListResponse>;
+export declare function fetchFormForgeResponse(http: FormForgeHttpAdapter, key: string, submissionId: string, options?: FormForgeRequestOptions): Promise<FormForgeJsonObject>;
+export declare function deleteFormForgeResponse(http: FormForgeHttpAdapter, key: string, submissionId: string, options?: FormForgeRequestOptions): Promise<FormForgeJsonObject>;
+//# sourceMappingURL=responses.d.ts.map