@drawbridge/drawbridge-utils 0.0.101 → 0.0.103

package/dist/fetch.cjs

@@ -32,7 +32,8 @@ __export(fetch_exports, {
   isTransientError: () => isTransientError,
   queryString: () => queryString,
   request: () => request,
-  setMemoryToken: () => setMemoryToken
+  setMemoryToken: () => setMemoryToken,
+  upload: () => upload
 });
 module.exports = __toCommonJS(fetch_exports);
 var import_qs = __toESM(require("qs"), 1);
@@ -122,6 +123,59 @@ var request = async ({
   }
   return res;
 };
+var upload = ({
+  body,
+  endpoint,
+  method = "POST",
+  onProgress,
+  signal,
+  token,
+  url = process.env.NEXT_PUBLIC_API_URI
+}) => {
+  const authToken = token || (typeof window !== "undefined" ? memoryToken : null);
+  const csrf = readCsrf();
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url + endpoint, true);
+    xhr.setRequestHeader("accept", "application/json");
+    if (authToken) {
+      xhr.setRequestHeader("authorization", "Bearer " + authToken);
+    }
+    if (csrf) {
+      xhr.setRequestHeader("x-drawbridge-csrf", csrf);
+    }
+    xhr.upload.addEventListener("progress", (event) => {
+      if (!event.lengthComputable || !onProgress) return;
+      onProgress({
+        bytesTotal: event.total,
+        bytesUploaded: event.loaded
+      });
+    });
+    xhr.addEventListener("load", () => {
+      let data = null;
+      try {
+        data = JSON.parse(xhr.responseText);
+      } catch {
+        data = null;
+      }
+      if (xhr.status >= 200 && xhr.status < 300) return resolve(data);
+      const error = new Error((data == null ? void 0 : data.message) || xhr.statusText);
+      error.status = xhr.status;
+      error.data = data;
+      reject(error);
+    });
+    xhr.addEventListener("abort", () => {
+      const error = new Error("Upload cancelled");
+      error.name = "AbortError";
+      reject(error);
+    });
+    xhr.addEventListener("error", () => reject(new Error("Network error")));
+    if (signal) {
+      signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+};
 var isTransientError = (error) => {
   const status = error == null ? void 0 : error.status;
   return !status || status === 429 || status >= 500;
@@ -131,5 +185,6 @@ var isTransientError = (error) => {
   isTransientError,
   queryString,
   request,
-  setMemoryToken
+  setMemoryToken,
+  upload
 });

package/dist/fetch.d.cts

@@ -124,6 +124,118 @@ const request = async ({
 
 };
 
+// fetch() has no upload-progress event and never will, which is the reason every
+// upload in the dashboard could only ever show a spinner. XHR does, so anything
+// that wants a real progress bar posts through here instead.
+//
+// It lives beside request() rather than in the dashboard because `memoryToken`
+// above is module-private on purpose — a copy in app-web could only read it if
+// the token were exported, which is the one thing setMemoryToken exists to
+// prevent. The csrf cookie read is here too.
+//
+// The error shape is deliberately identical to request()'s — an Error carrying
+// .status and .data — so isTransientError() and every existing catch block work
+// against either transport without knowing which ran.
+const upload = ({
+	body,
+	endpoint,
+	method = 'POST',
+	onProgress,
+	signal,
+	token,
+	url = process.env.NEXT_PUBLIC_API_URI
+}) => {
+
+	const authToken = token || ( typeof window !== 'undefined' ? memoryToken : null );
+	const csrf = readCsrf();
+
+	return new Promise( ( resolve, reject ) => {
+
+		const xhr = new XMLHttpRequest();
+
+		xhr.open( method, url + endpoint, true );
+
+		// No content-type, ever. The browser has to write the multipart boundary
+		// itself and setting the header by hand drops it, which busboy then
+		// rejects. Nor origin: it is a forbidden header name, so the browser
+		// ignores setRequestHeader for it ( request() only sets it because its
+		// server-side callers run where fetch allows it ).
+		xhr.setRequestHeader( 'accept', 'application/json' );
+
+		if( authToken ){
+
+			xhr.setRequestHeader( 'authorization', 'Bearer ' + authToken );
+
+		}
+
+		if( csrf ){
+
+			xhr.setRequestHeader( 'x-drawbridge-csrf', csrf );
+
+		}
+
+		xhr.upload.addEventListener( 'progress', ( event ) => {
+
+			if( ! event.lengthComputable || ! onProgress ) return;
+
+			onProgress({
+				bytesTotal : event.total,
+				bytesUploaded : event.loaded
+			});
+
+		});
+
+		xhr.addEventListener( 'load', () => {
+
+			let data = null;
+
+			try {
+
+				data = JSON.parse( xhr.responseText );
+
+			} catch {
+
+				data = null;
+
+			}
+
+			if( xhr.status >= 200 && xhr.status < 300 ) return resolve( data );
+
+			const error = new Error( data?.message || xhr.statusText );
+
+			error.status = xhr.status;
+			error.data = data;
+
+			reject( error );
+
+		});
+
+		xhr.addEventListener( 'abort', () => {
+
+			const error = new Error( 'Upload cancelled' );
+
+			error.name = 'AbortError';
+
+			reject( error );
+
+		});
+
+		// No status on a network failure, which is exactly how isTransientError
+		// classifies it — worth a retry rather than a sign-in bounce.
+		xhr.addEventListener( 'error', () => reject( new Error( 'Network error' ) ) );
+
+		if( signal ){
+
+			signal.addEventListener( 'abort', () => xhr.abort(), { once : true } );
+
+		}
+
+		xhr.send( body );
+
+	});
+
+};
+
 // Classifies an error thrown by request() — which carries `.status` from the
 // HTTP response, or no status for a network / parse failure. Transient errors
 // ( rate limits, server errors, connection blips ) may succeed on retry, so
@@ -139,4 +251,4 @@ const isTransientError = ( error ) => {
 
 };
 
-export { isTransientError, queryString, request, setMemoryToken };
+export { isTransientError, queryString, request, setMemoryToken, upload };

package/dist/fetch.d.ts

@@ -124,6 +124,118 @@ const request = async ({
 
 };
 
+// fetch() has no upload-progress event and never will, which is the reason every
+// upload in the dashboard could only ever show a spinner. XHR does, so anything
+// that wants a real progress bar posts through here instead.
+//
+// It lives beside request() rather than in the dashboard because `memoryToken`
+// above is module-private on purpose — a copy in app-web could only read it if
+// the token were exported, which is the one thing setMemoryToken exists to
+// prevent. The csrf cookie read is here too.
+//
+// The error shape is deliberately identical to request()'s — an Error carrying
+// .status and .data — so isTransientError() and every existing catch block work
+// against either transport without knowing which ran.
+const upload = ({
+	body,
+	endpoint,
+	method = 'POST',
+	onProgress,
+	signal,
+	token,
+	url = process.env.NEXT_PUBLIC_API_URI
+}) => {
+
+	const authToken = token || ( typeof window !== 'undefined' ? memoryToken : null );
+	const csrf = readCsrf();
+
+	return new Promise( ( resolve, reject ) => {
+
+		const xhr = new XMLHttpRequest();
+
+		xhr.open( method, url + endpoint, true );
+
+		// No content-type, ever. The browser has to write the multipart boundary
+		// itself and setting the header by hand drops it, which busboy then
+		// rejects. Nor origin: it is a forbidden header name, so the browser
+		// ignores setRequestHeader for it ( request() only sets it because its
+		// server-side callers run where fetch allows it ).
+		xhr.setRequestHeader( 'accept', 'application/json' );
+
+		if( authToken ){
+
+			xhr.setRequestHeader( 'authorization', 'Bearer ' + authToken );
+
+		}
+
+		if( csrf ){
+
+			xhr.setRequestHeader( 'x-drawbridge-csrf', csrf );
+
+		}
+
+		xhr.upload.addEventListener( 'progress', ( event ) => {
+
+			if( ! event.lengthComputable || ! onProgress ) return;
+
+			onProgress({
+				bytesTotal : event.total,
+				bytesUploaded : event.loaded
+			});
+
+		});
+
+		xhr.addEventListener( 'load', () => {
+
+			let data = null;
+
+			try {
+
+				data = JSON.parse( xhr.responseText );
+
+			} catch {
+
+				data = null;
+
+			}
+
+			if( xhr.status >= 200 && xhr.status < 300 ) return resolve( data );
+
+			const error = new Error( data?.message || xhr.statusText );
+
+			error.status = xhr.status;
+			error.data = data;
+
+			reject( error );
+
+		});
+
+		xhr.addEventListener( 'abort', () => {
+
+			const error = new Error( 'Upload cancelled' );
+
+			error.name = 'AbortError';
+
+			reject( error );
+
+		});
+
+		// No status on a network failure, which is exactly how isTransientError
+		// classifies it — worth a retry rather than a sign-in bounce.
+		xhr.addEventListener( 'error', () => reject( new Error( 'Network error' ) ) );
+
+		if( signal ){
+
+			signal.addEventListener( 'abort', () => xhr.abort(), { once : true } );
+
+		}
+
+		xhr.send( body );
+
+	});
+
+};
+
 // Classifies an error thrown by request() — which carries `.status` from the
 // HTTP response, or no status for a network / parse failure. Transient errors
 // ( rate limits, server errors, connection blips ) may succeed on retry, so
@@ -139,4 +251,4 @@ const isTransientError = ( error ) => {
 
 };
 
-export { isTransientError, queryString, request, setMemoryToken };
+export { isTransientError, queryString, request, setMemoryToken, upload };

package/dist/fetch.js

@@ -86,6 +86,59 @@ var request = async ({
   }
   return res;
 };
+var upload = ({
+  body,
+  endpoint,
+  method = "POST",
+  onProgress,
+  signal,
+  token,
+  url = process.env.NEXT_PUBLIC_API_URI
+}) => {
+  const authToken = token || (typeof window !== "undefined" ? memoryToken : null);
+  const csrf = readCsrf();
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url + endpoint, true);
+    xhr.setRequestHeader("accept", "application/json");
+    if (authToken) {
+      xhr.setRequestHeader("authorization", "Bearer " + authToken);
+    }
+    if (csrf) {
+      xhr.setRequestHeader("x-drawbridge-csrf", csrf);
+    }
+    xhr.upload.addEventListener("progress", (event) => {
+      if (!event.lengthComputable || !onProgress) return;
+      onProgress({
+        bytesTotal: event.total,
+        bytesUploaded: event.loaded
+      });
+    });
+    xhr.addEventListener("load", () => {
+      let data = null;
+      try {
+        data = JSON.parse(xhr.responseText);
+      } catch {
+        data = null;
+      }
+      if (xhr.status >= 200 && xhr.status < 300) return resolve(data);
+      const error = new Error((data == null ? void 0 : data.message) || xhr.statusText);
+      error.status = xhr.status;
+      error.data = data;
+      reject(error);
+    });
+    xhr.addEventListener("abort", () => {
+      const error = new Error("Upload cancelled");
+      error.name = "AbortError";
+      reject(error);
+    });
+    xhr.addEventListener("error", () => reject(new Error("Network error")));
+    if (signal) {
+      signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+};
 var isTransientError = (error) => {
   const status = error == null ? void 0 : error.status;
   return !status || status === 429 || status >= 500;
@@ -94,5 +147,6 @@ export {
   isTransientError,
   queryString,
   request,
-  setMemoryToken
+  setMemoryToken,
+  upload
 };

package/dist/fields-validate.cjs

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/fields-validate.js
+var fields_validate_exports = {};
+__export(fields_validate_exports, {
+  errors: () => errors,
+  validators: () => validators
+});
+module.exports = __toCommonJS(fields_validate_exports);
+
+// lib/phone.js
+var import_libphonenumber_js = require("libphonenumber-js");
+var isValid = (value, country) => {
+  if (!value) return false;
+  try {
+    return (0, import_libphonenumber_js.isValidPhoneNumber)(String(value), country);
+  } catch {
+    return false;
+  }
+};
+
+// lib/fields-validate.js
+var errors = {
+  country: "Field is not an accepted value",
+  email: "Field value must be a valid email",
+  length: (length) => "Field must be less than or equal to " + length + " characters",
+  max: (val) => "Field value must be less than or equal to " + val,
+  min: (val) => "Field value must be greater than or equal to " + val,
+  option: "Field is not an accepted value",
+  phone: "Field value is not valid",
+  required: "Field is required"
+};
+var required = (field, schema) => {
+  var _a;
+  return ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.required) === false ? schema.nullable() : schema.required(errors.required);
+};
+var validators = {
+  // An agreement that is not required is not an agreement - consent stays
+  // affirmative regardless of the toggle.
+  agreement: (field, yup) => {
+    return yup.bool().required(errors.required).oneOf([true], errors.required);
+  },
+  email: (field, yup) => {
+    const max = 320;
+    return required(field, yup.string().email(errors.email).max(max, errors.length(max)));
+  },
+  name: (field, yup) => {
+    var _a;
+    const max = 150;
+    const object = (((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.capture) || []).reduce(
+      (accumulator, item) => {
+        accumulator[item] = yup.string().required(errors.required).max(max, errors.length(max));
+        return accumulator;
+      },
+      {}
+    );
+    return required(field, yup.object(object));
+  },
+  number: (field, yup) => {
+    var _a, _b, _c, _d, _e, _f;
+    let validate = yup.number();
+    if ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.min) {
+      validate = validate.min((_b = field == null ? void 0 : field.attributes) == null ? void 0 : _b.min, errors.min((_c = field == null ? void 0 : field.attributes) == null ? void 0 : _c.min));
+    }
+    ;
+    if ((_d = field == null ? void 0 : field.attributes) == null ? void 0 : _d.max) {
+      validate = validate.max((_e = field == null ? void 0 : field.attributes) == null ? void 0 : _e.max, errors.max((_f = field == null ? void 0 : field.attributes) == null ? void 0 : _f.max));
+    }
+    ;
+    return required(field, validate);
+  },
+  phone: (field, yup) => {
+    var _a;
+    return required(
+      field,
+      yup.object({
+        country: yup.string().required(errors.required).oneOf((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.countries, errors.country),
+        number: yup.string().required(errors.required)
+      }).test("phone", errors.phone, (value) => isValid(value == null ? void 0 : value.number, value == null ? void 0 : value.country))
+    );
+  },
+  // The in-list check the share form never had: the answer must be one of the
+  // field's own options. null rides the whitelist so an optional select can be
+  // left blank - required() still rejects null when the field is required.
+  select: (field, yup) => {
+    var _a;
+    const options = (((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.options) || []).map((item) => item == null ? void 0 : item.option);
+    return required(field, yup.string().oneOf([...options, null], errors.option));
+  },
+  text: (field, yup) => {
+    var _a;
+    const max = ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.max) || 150;
+    return required(field, yup.string().max(max, errors.length(max)));
+  },
+  textarea: (field, yup) => {
+    var _a;
+    const max = ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.max) || 150;
+    return required(field, yup.string().max(max, errors.length(max)));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errors,
+  validators
+});

package/dist/fields-validate.d.cts

@@ -0,0 +1,116 @@
+import { isValid } from './phone.cjs';
+import 'libphonenumber-js';
+
+// Field validators shared by the share form (client) and the api submission
+// route (server). They lived only in drawbridge-share, so every additional-field
+// answer - number, select, text, textarea - was validated in the browser and
+// stored as submitted; the api only ever validated lead fields.
+//
+// yup is passed in rather than imported so each consumer keeps its own copy
+// (share bundles one, api has its own in lib/validate).
+
+
+const errors = {
+	country : 'Field is not an accepted value',
+	email : 'Field value must be a valid email',
+	length : ( length ) => 'Field must be less than or equal to ' + length + ' characters',
+	max : ( val ) => 'Field value must be less than or equal to ' + val,
+	min : ( val ) => 'Field value must be greater than or equal to ' + val,
+	option : 'Field is not an accepted value',
+	phone : 'Field value is not valid',
+	required : 'Field is required'
+};
+
+// Every stored attributes.required is currently true, so this is a no-op today -
+// it is here so the optional-field toggle does not need a second pass over
+// every builder.
+const required = ( field, schema ) => ( field?.attributes?.required === false ) ? schema.nullable() : schema.required( errors.required );
+
+const validators = {
+	// An agreement that is not required is not an agreement - consent stays
+	// affirmative regardless of the toggle.
+	agreement : ( field, yup ) => {
+
+		return yup.bool().required( errors.required ).oneOf( [ true ], errors.required );
+
+	},
+	email : ( field, yup ) => {
+
+		const max = 320;
+
+		return required( field, yup.string().email( errors.email ).max( max, errors.length( max ) ) );
+
+	},
+	name : ( field, yup ) => {
+
+		const max = 150;
+
+		const object = ( field?.settings?.capture || [] ).reduce(
+			( accumulator, item ) => {
+
+				accumulator[ item ] = yup.string().required( errors.required ).max( max, errors.length( max ) );
+
+				return accumulator;
+
+			},
+			{}
+		);
+
+		return required( field, yup.object( object ) );
+
+	},
+	number : ( field, yup ) => {
+
+		let validate = yup.number();
+
+		if( field?.attributes?.min ){
+
+			validate = validate.min( field?.attributes?.min, errors.min( field?.attributes?.min ) );
+
+		}
+		if( field?.attributes?.max ){
+
+			validate = validate.max( field?.attributes?.max, errors.max( field?.attributes?.max ) );
+
+		}
+		return required( field, validate );
+
+	},
+	phone : ( field, yup ) => {
+
+		return required(
+			field,
+			yup.object({
+				country : yup.string().required( errors.required ).oneOf( field?.settings?.countries, errors.country ),
+				number : yup.string().required( errors.required )
+			}).test( 'phone', errors.phone, ( value ) => isValid( value?.number, value?.country ) )
+		);
+
+	},
+	// The in-list check the share form never had: the answer must be one of the
+	// field's own options. null rides the whitelist so an optional select can be
+	// left blank - required() still rejects null when the field is required.
+	select : ( field, yup ) => {
+
+		const options = ( field?.settings?.options || [] ).map( ( item ) => item?.option );
+
+		return required( field, yup.string().oneOf( [ ...options, null ], errors.option ) );
+
+	},
+	text : ( field, yup ) => {
+
+		const max = field?.attributes?.max || 150;
+
+		return required( field, yup.string().max( max, errors.length( max ) ) );
+
+	},
+	textarea : ( field, yup ) => {
+
+		const max = field?.attributes?.max || 150;
+
+		return required( field, yup.string().max( max, errors.length( max ) ) );
+
+	}
+};
+
+export { errors, validators };

package/dist/fields-validate.d.ts

@@ -0,0 +1,116 @@
+import { isValid } from './phone.js';
+import 'libphonenumber-js';
+
+// Field validators shared by the share form (client) and the api submission
+// route (server). They lived only in drawbridge-share, so every additional-field
+// answer - number, select, text, textarea - was validated in the browser and
+// stored as submitted; the api only ever validated lead fields.
+//
+// yup is passed in rather than imported so each consumer keeps its own copy
+// (share bundles one, api has its own in lib/validate).
+
+
+const errors = {
+	country : 'Field is not an accepted value',
+	email : 'Field value must be a valid email',
+	length : ( length ) => 'Field must be less than or equal to ' + length + ' characters',
+	max : ( val ) => 'Field value must be less than or equal to ' + val,
+	min : ( val ) => 'Field value must be greater than or equal to ' + val,
+	option : 'Field is not an accepted value',
+	phone : 'Field value is not valid',
+	required : 'Field is required'
+};
+
+// Every stored attributes.required is currently true, so this is a no-op today -
+// it is here so the optional-field toggle does not need a second pass over
+// every builder.
+const required = ( field, schema ) => ( field?.attributes?.required === false ) ? schema.nullable() : schema.required( errors.required );
+
+const validators = {
+	// An agreement that is not required is not an agreement - consent stays
+	// affirmative regardless of the toggle.
+	agreement : ( field, yup ) => {
+
+		return yup.bool().required( errors.required ).oneOf( [ true ], errors.required );
+
+	},
+	email : ( field, yup ) => {
+
+		const max = 320;
+
+		return required( field, yup.string().email( errors.email ).max( max, errors.length( max ) ) );
+
+	},
+	name : ( field, yup ) => {
+
+		const max = 150;
+
+		const object = ( field?.settings?.capture || [] ).reduce(
+			( accumulator, item ) => {
+
+				accumulator[ item ] = yup.string().required( errors.required ).max( max, errors.length( max ) );
+
+				return accumulator;
+
+			},
+			{}
+		);
+
+		return required( field, yup.object( object ) );
+
+	},
+	number : ( field, yup ) => {
+
+		let validate = yup.number();
+
+		if( field?.attributes?.min ){
+
+			validate = validate.min( field?.attributes?.min, errors.min( field?.attributes?.min ) );
+
+		}
+		if( field?.attributes?.max ){
+
+			validate = validate.max( field?.attributes?.max, errors.max( field?.attributes?.max ) );
+
+		}
+		return required( field, validate );
+
+	},
+	phone : ( field, yup ) => {
+
+		return required(
+			field,
+			yup.object({
+				country : yup.string().required( errors.required ).oneOf( field?.settings?.countries, errors.country ),
+				number : yup.string().required( errors.required )
+			}).test( 'phone', errors.phone, ( value ) => isValid( value?.number, value?.country ) )
+		);
+
+	},
+	// The in-list check the share form never had: the answer must be one of the
+	// field's own options. null rides the whitelist so an optional select can be
+	// left blank - required() still rejects null when the field is required.
+	select : ( field, yup ) => {
+
+		const options = ( field?.settings?.options || [] ).map( ( item ) => item?.option );
+
+		return required( field, yup.string().oneOf( [ ...options, null ], errors.option ) );
+
+	},
+	text : ( field, yup ) => {
+
+		const max = field?.attributes?.max || 150;
+
+		return required( field, yup.string().max( max, errors.length( max ) ) );
+
+	},
+	textarea : ( field, yup ) => {
+
+		const max = field?.attributes?.max || 150;
+
+		return required( field, yup.string().max( max, errors.length( max ) ) );
+
+	}
+};
+
+export { errors, validators };

package/dist/fields-validate.js

@@ -0,0 +1,94 @@
+// lib/phone.js
+import { parsePhoneNumberFromString, isValidPhoneNumber } from "libphonenumber-js";
+var isValid = (value, country) => {
+  if (!value) return false;
+  try {
+    return isValidPhoneNumber(String(value), country);
+  } catch {
+    return false;
+  }
+};
+
+// lib/fields-validate.js
+var errors = {
+  country: "Field is not an accepted value",
+  email: "Field value must be a valid email",
+  length: (length) => "Field must be less than or equal to " + length + " characters",
+  max: (val) => "Field value must be less than or equal to " + val,
+  min: (val) => "Field value must be greater than or equal to " + val,
+  option: "Field is not an accepted value",
+  phone: "Field value is not valid",
+  required: "Field is required"
+};
+var required = (field, schema) => {
+  var _a;
+  return ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.required) === false ? schema.nullable() : schema.required(errors.required);
+};
+var validators = {
+  // An agreement that is not required is not an agreement - consent stays
+  // affirmative regardless of the toggle.
+  agreement: (field, yup) => {
+    return yup.bool().required(errors.required).oneOf([true], errors.required);
+  },
+  email: (field, yup) => {
+    const max = 320;
+    return required(field, yup.string().email(errors.email).max(max, errors.length(max)));
+  },
+  name: (field, yup) => {
+    var _a;
+    const max = 150;
+    const object = (((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.capture) || []).reduce(
+      (accumulator, item) => {
+        accumulator[item] = yup.string().required(errors.required).max(max, errors.length(max));
+        return accumulator;
+      },
+      {}
+    );
+    return required(field, yup.object(object));
+  },
+  number: (field, yup) => {
+    var _a, _b, _c, _d, _e, _f;
+    let validate = yup.number();
+    if ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.min) {
+      validate = validate.min((_b = field == null ? void 0 : field.attributes) == null ? void 0 : _b.min, errors.min((_c = field == null ? void 0 : field.attributes) == null ? void 0 : _c.min));
+    }
+    ;
+    if ((_d = field == null ? void 0 : field.attributes) == null ? void 0 : _d.max) {
+      validate = validate.max((_e = field == null ? void 0 : field.attributes) == null ? void 0 : _e.max, errors.max((_f = field == null ? void 0 : field.attributes) == null ? void 0 : _f.max));
+    }
+    ;
+    return required(field, validate);
+  },
+  phone: (field, yup) => {
+    var _a;
+    return required(
+      field,
+      yup.object({
+        country: yup.string().required(errors.required).oneOf((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.countries, errors.country),
+        number: yup.string().required(errors.required)
+      }).test("phone", errors.phone, (value) => isValid(value == null ? void 0 : value.number, value == null ? void 0 : value.country))
+    );
+  },
+  // The in-list check the share form never had: the answer must be one of the
+  // field's own options. null rides the whitelist so an optional select can be
+  // left blank - required() still rejects null when the field is required.
+  select: (field, yup) => {
+    var _a;
+    const options = (((_a = field == null ? void 0 : field.settings) == null ? void 0 : _a.options) || []).map((item) => item == null ? void 0 : item.option);
+    return required(field, yup.string().oneOf([...options, null], errors.option));
+  },
+  text: (field, yup) => {
+    var _a;
+    const max = ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.max) || 150;
+    return required(field, yup.string().max(max, errors.length(max)));
+  },
+  textarea: (field, yup) => {
+    var _a;
+    const max = ((_a = field == null ? void 0 : field.attributes) == null ? void 0 : _a.max) || 150;
+    return required(field, yup.string().max(max, errors.length(max)));
+  }
+};
+export {
+  errors,
+  validators
+};

package/dist/upload.cjs

@@ -22,7 +22,10 @@ __export(upload_exports, {
   allowedMimes: () => allowedMimes,
   allowedUploadTypes: () => allowedUploadTypes,
   isAllowedMime: () => isAllowedMime,
-  resolveUploadType: () => resolveUploadType
+  maximumUploadBytes: () => maximumUploadBytes,
+  resolveUploadType: () => resolveUploadType,
+  uploadPartCount: () => uploadPartCount,
+  uploadPartSize: () => uploadPartSize
 });
 module.exports = __toCommonJS(upload_exports);
 var allowedUploadTypes = {
@@ -36,6 +39,11 @@ var allowedUploadTypes = {
     webp: "image/webp"
   },
   video: {
+    // iPhones record .mov (HEVC) by default, so this is the single most
+    // likely video a merchant uploads. sync's storage.js already computes
+    // needsReencode for hevc/h265 and re-encodes to h264, so allowing it
+    // here is the only thing the pipeline was waiting on.
+    mov: "video/quicktime",
     mp4: "video/mp4"
   }
 };
@@ -56,10 +64,27 @@ var resolveUploadType = (type, extension) => {
   return mime;
 };
 var isAllowedMime = (mime) => allowedMimes.has(mime);
+var megabyte = 1024 * 1024;
+var maximumUploadBytes = 2048 * megabyte;
+var maximumParts = 9e3;
+var minimumPartSize = 10 * megabyte;
+var uploadPartSize = (bytes) => {
+  const size = Number(bytes) || 0;
+  const required = Math.ceil(size / maximumParts);
+  const rounded = Math.ceil(required / megabyte) * megabyte;
+  return Math.max(minimumPartSize, rounded);
+};
+var uploadPartCount = (bytes) => {
+  const size = Number(bytes) || 0;
+  return Math.max(1, Math.ceil(size / uploadPartSize(size)));
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   allowedMimes,
   allowedUploadTypes,
   isAllowedMime,
-  resolveUploadType
+  maximumUploadBytes,
+  resolveUploadType,
+  uploadPartCount,
+  uploadPartSize
 });

package/dist/upload.d.cts

@@ -15,6 +15,12 @@
 //
 // Why both helpers and not just one: api routes know (type, extension) but not
 // the canonical mime; sync workers have the mime but not the original type tuple.
+//
+// A third consumer joined with presigned multipart uploads: the dashboard reads
+// this same object to build its file picker's accept attribute and the uploader's
+// client-side restrictions, so a wrong type is refused before two gigabytes move
+// rather than after. That is the whole reason the list is not copied into
+// app-web — four views of one list can't drift.
 
 const allowedUploadTypes = {
 	application : {
@@ -27,6 +33,11 @@ const allowedUploadTypes = {
 		webp : 'image/webp'
 	},
 	video : {
+		// iPhones record .mov (HEVC) by default, so this is the single most
+		// likely video a merchant uploads. sync's storage.js already computes
+		// needsReencode for hevc/h265 and re-encodes to h264, so allowing it
+		// here is the only thing the pipeline was waiting on.
+		mov : 'video/quicktime',
 		mp4 : 'video/mp4'
 	}
 };
@@ -55,4 +66,51 @@ const resolveUploadType = ( type, extension ) => {
 
 const isAllowedMime = ( mime ) => allowedMimes.has( mime );
 
-export { allowedMimes, allowedUploadTypes, isAllowedMime, resolveUploadType };
+const megabyte = ( 1024 * 1024 );
+
+// The ceiling for a presigned multipart upload. Video streams browser-to-bucket
+// on that path rather than through the api, so this is a product decision
+// rather than the fleet-protection one that keeps the single-request busboy
+// route at 50MB.
+//
+// It lives here because both sides have to agree on it exactly: the dashboard
+// rejects before transferring and the api rejects authoritatively, and if the
+// two numbers drift the client blocks files the api would happily accept.
+const maximumUploadBytes = ( 2048 * megabyte );
+
+// S3 caps a multipart upload at 10,000 parts and requires every part except the
+// last to be at least 5MB. A fixed part size therefore puts a silent ceiling on
+// the maximum file, so the size is derived from the declared length with
+// headroom against the hard limit.
+//
+// The 10MB floor is a request-volume decision, not an S3 one: a 2GB upload at
+// 5MB parts is 410 signing calls, at 10MB it is 205.
+//
+// Both the api and the dashboard call this, and the dashboard *must* — Uppy
+// builds its chunk list in the MultipartUploader constructor, which runs before
+// createMultipartUpload is ever called, so a part size returned from the create
+// endpoint arrives too late to chunk with. One function, two callers, no
+// possibility of disagreeing about where the part boundaries fall.
+const maximumParts = 9000;
+const minimumPartSize = ( 10 * megabyte );
+
+const uploadPartSize = ( bytes ) => {
+
+	const size = Number( bytes ) || 0;
+	const required = Math.ceil( size / maximumParts );
+	const rounded = Math.ceil( required / megabyte ) * megabyte;
+
+	return Math.max( minimumPartSize, rounded );
+
+};
+
+// An empty upload is still one part — S3 has no zero-part upload.
+const uploadPartCount = ( bytes ) => {
+
+	const size = Number( bytes ) || 0;
+
+	return Math.max( 1, Math.ceil( size / uploadPartSize( size ) ) );
+
+};
+
+export { allowedMimes, allowedUploadTypes, isAllowedMime, maximumUploadBytes, resolveUploadType, uploadPartCount, uploadPartSize };

package/dist/upload.d.ts

@@ -15,6 +15,12 @@
 //
 // Why both helpers and not just one: api routes know (type, extension) but not
 // the canonical mime; sync workers have the mime but not the original type tuple.
+//
+// A third consumer joined with presigned multipart uploads: the dashboard reads
+// this same object to build its file picker's accept attribute and the uploader's
+// client-side restrictions, so a wrong type is refused before two gigabytes move
+// rather than after. That is the whole reason the list is not copied into
+// app-web — four views of one list can't drift.
 
 const allowedUploadTypes = {
 	application : {
@@ -27,6 +33,11 @@ const allowedUploadTypes = {
 		webp : 'image/webp'
 	},
 	video : {
+		// iPhones record .mov (HEVC) by default, so this is the single most
+		// likely video a merchant uploads. sync's storage.js already computes
+		// needsReencode for hevc/h265 and re-encodes to h264, so allowing it
+		// here is the only thing the pipeline was waiting on.
+		mov : 'video/quicktime',
 		mp4 : 'video/mp4'
 	}
 };
@@ -55,4 +66,51 @@ const resolveUploadType = ( type, extension ) => {
 
 const isAllowedMime = ( mime ) => allowedMimes.has( mime );
 
-export { allowedMimes, allowedUploadTypes, isAllowedMime, resolveUploadType };
+const megabyte = ( 1024 * 1024 );
+
+// The ceiling for a presigned multipart upload. Video streams browser-to-bucket
+// on that path rather than through the api, so this is a product decision
+// rather than the fleet-protection one that keeps the single-request busboy
+// route at 50MB.
+//
+// It lives here because both sides have to agree on it exactly: the dashboard
+// rejects before transferring and the api rejects authoritatively, and if the
+// two numbers drift the client blocks files the api would happily accept.
+const maximumUploadBytes = ( 2048 * megabyte );
+
+// S3 caps a multipart upload at 10,000 parts and requires every part except the
+// last to be at least 5MB. A fixed part size therefore puts a silent ceiling on
+// the maximum file, so the size is derived from the declared length with
+// headroom against the hard limit.
+//
+// The 10MB floor is a request-volume decision, not an S3 one: a 2GB upload at
+// 5MB parts is 410 signing calls, at 10MB it is 205.
+//
+// Both the api and the dashboard call this, and the dashboard *must* — Uppy
+// builds its chunk list in the MultipartUploader constructor, which runs before
+// createMultipartUpload is ever called, so a part size returned from the create
+// endpoint arrives too late to chunk with. One function, two callers, no
+// possibility of disagreeing about where the part boundaries fall.
+const maximumParts = 9000;
+const minimumPartSize = ( 10 * megabyte );
+
+const uploadPartSize = ( bytes ) => {
+
+	const size = Number( bytes ) || 0;
+	const required = Math.ceil( size / maximumParts );
+	const rounded = Math.ceil( required / megabyte ) * megabyte;
+
+	return Math.max( minimumPartSize, rounded );
+
+};
+
+// An empty upload is still one part — S3 has no zero-part upload.
+const uploadPartCount = ( bytes ) => {
+
+	const size = Number( bytes ) || 0;
+
+	return Math.max( 1, Math.ceil( size / uploadPartSize( size ) ) );
+
+};
+
+export { allowedMimes, allowedUploadTypes, isAllowedMime, maximumUploadBytes, resolveUploadType, uploadPartCount, uploadPartSize };

package/dist/upload.js

@@ -10,6 +10,11 @@ var allowedUploadTypes = {
     webp: "image/webp"
   },
   video: {
+    // iPhones record .mov (HEVC) by default, so this is the single most
+    // likely video a merchant uploads. sync's storage.js already computes
+    // needsReencode for hevc/h265 and re-encodes to h264, so allowing it
+    // here is the only thing the pipeline was waiting on.
+    mov: "video/quicktime",
     mp4: "video/mp4"
   }
 };
@@ -30,9 +35,26 @@ var resolveUploadType = (type, extension) => {
   return mime;
 };
 var isAllowedMime = (mime) => allowedMimes.has(mime);
+var megabyte = 1024 * 1024;
+var maximumUploadBytes = 2048 * megabyte;
+var maximumParts = 9e3;
+var minimumPartSize = 10 * megabyte;
+var uploadPartSize = (bytes) => {
+  const size = Number(bytes) || 0;
+  const required = Math.ceil(size / maximumParts);
+  const rounded = Math.ceil(required / megabyte) * megabyte;
+  return Math.max(minimumPartSize, rounded);
+};
+var uploadPartCount = (bytes) => {
+  const size = Number(bytes) || 0;
+  return Math.max(1, Math.ceil(size / uploadPartSize(size)));
+};
 export {
   allowedMimes,
   allowedUploadTypes,
   isAllowedMime,
-  resolveUploadType
+  maximumUploadBytes,
+  resolveUploadType,
+  uploadPartCount,
+  uploadPartSize
 };

package/package.json

@@ -13,10 +13,11 @@
     "tinycolor2": "1.6.0"
   },
   "devDependencies": {
-    "@drawbridge/drawbridge-agents": "0.1.33",
+    "@drawbridge/drawbridge-agents": "0.1.37",
     "@node-oauth/oauth2-server": "5.3.0",
     "tsup": "8.5.1",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "yup": "1.7.1"
   },
   "peerDependencies": {
     "@node-oauth/oauth2-server": "^5.3.0"
@@ -161,6 +162,11 @@
       "types": "./dist/plans.d.ts",
       "import": "./dist/plans.js",
       "require": "./dist/plans.cjs"
+    },
+    "./fields-validate": {
+      "types": "./dist/fields-validate.d.ts",
+      "import": "./dist/fields-validate.js",
+      "require": "./dist/fields-validate.cjs"
     }
   },
   "files": [
@@ -179,5 +185,5 @@
     "test": ". \"$HOME/.nvm/nvm.sh\" && nvm use && node --test"
   },
   "types": "dist/index.d.ts",
-  "version": "0.0.101"
+  "version": "0.0.103"
 }