@holo-js/forms 0.1.4 → 0.1.6

package/dist/chunk-GH4IN2OV.mjs

@@ -0,0 +1,59 @@
+import {
+  FormContractError
+} from "./chunk-OFPH5LBY.mjs";
+
+// src/security-shared.ts
+function isMissingOptionalPackageError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return [
+    /Cannot find package ['"]?@holo-js\/security['"]?/,
+    /Cannot find module ['"]?@holo-js\/security['"]?/,
+    /Failed to resolve module specifier ['"]?@holo-js\/security['"]?/,
+    /Failed to load url ['"]?@holo-js\/security['"]?/,
+    /Could not resolve ['"]?@holo-js\/security['"]?/
+  ].some((pattern) => pattern.test(error.message));
+}
+function createMissingSecurityPackageError() {
+  return new FormContractError(
+    "[@holo-js/forms] Security-aware form options require the optional @holo-js/security package to be installed."
+  );
+}
+function parseCookieHeader(header) {
+  const decodeCookiePart = (value) => {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return void 0;
+    }
+  };
+  return Object.freeze(Object.fromEntries(
+    header.split(";").map((segment) => segment.trim()).filter(Boolean).map((segment) => {
+      const separator = segment.indexOf("=");
+      if (separator <= 0) {
+        return void 0;
+      }
+      const key = decodeCookiePart(segment.slice(0, separator));
+      const value = decodeCookiePart(segment.slice(separator + 1));
+      if (!key || typeof value === "undefined") {
+        return void 0;
+      }
+      return [
+        key,
+        value
+      ];
+    }).filter((entry) => !!entry)
+  ));
+}
+function isRootSecurityError(error) {
+  const candidate = error;
+  return error instanceof Error && typeof candidate?.status === "number" && (candidate.status === 419 || candidate.status === 429);
+}
+
+export {
+  isMissingOptionalPackageError,
+  createMissingSecurityPackageError,
+  parseCookieHeader,
+  isRootSecurityError
+};

package/dist/chunk-GPWXGHZE.mjs

@@ -0,0 +1,40 @@
+// src/schema.ts
+import {
+  defineSchema,
+  isValidationSchema
+} from "@holo-js/validation";
+import {
+  createErrorBag,
+  DEFAULT_VALIDATION_BAG,
+  defineSchema as defineSchema2,
+  field,
+  isValidationException,
+  parse,
+  safeParse,
+  ValidationException,
+  validationInternals
+} from "@holo-js/validation";
+function schema(shapeOrSchema) {
+  const base = isValidationSchema(shapeOrSchema) ? shapeOrSchema : defineSchema(shapeOrSchema);
+  return Object.freeze({
+    ...base,
+    mode: "form"
+  });
+}
+function isFormSchema(value) {
+  return isValidationSchema(value) && value.mode === "form";
+}
+
+export {
+  schema,
+  isFormSchema,
+  createErrorBag,
+  DEFAULT_VALIDATION_BAG,
+  defineSchema2 as defineSchema,
+  field,
+  isValidationException,
+  parse,
+  safeParse,
+  ValidationException,
+  validationInternals
+};

package/dist/chunk-OFPH5LBY.mjs

@@ -0,0 +1,11 @@
+// src/errors.ts
+var FormContractError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FormContractError";
+  }
+};
+
+export {
+  FormContractError
+};

package/dist/chunk-WJOAU4V2.mjs

@@ -0,0 +1,162 @@
+import {
+  FormContractError
+} from "./chunk-OFPH5LBY.mjs";
+
+// src/failure.ts
+function normalizeStatus(value, fallback) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  if (!Number.isInteger(value) || value < 100) {
+    throw new FormContractError("HTTP status codes must be integers greater than or equal to 100.");
+  }
+  return value;
+}
+function normalizeFailureInput(input, fallbackStatus) {
+  if (typeof input === "number") {
+    return {
+      status: normalizeStatus(input, fallbackStatus)
+    };
+  }
+  return {
+    status: normalizeStatus(input?.status, fallbackStatus),
+    errors: input?.errors
+  };
+}
+function normalizeFailureErrors(fallback, override) {
+  if (!override) {
+    return fallback;
+  }
+  const normalized = { ...fallback };
+  for (const [field, messages] of Object.entries(override)) {
+    if (typeof messages !== "undefined") {
+      normalized[field] = messages;
+    }
+  }
+  return normalized;
+}
+
+// src/sensitiveInput.ts
+var DEFAULT_DONT_FLASH_FIELDS = Object.freeze([
+  "confirm_password",
+  "confirmPassword",
+  "current_password",
+  "currentPassword",
+  "new_password",
+  "newPassword",
+  "password",
+  "password_confirmation",
+  "passwordConfirmation"
+]);
+var DEFAULT_DONT_FLASH_FIELD_SET = new Set(DEFAULT_DONT_FLASH_FIELDS);
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
+}
+function isFieldDefinition(value) {
+  return isPlainObject(value) && typeof value.kind === "string" && Array.isArray(value.rules);
+}
+function isSchemaField(value) {
+  return isPlainObject(value) && value.kind === "field" && isFieldDefinition(value.definition);
+}
+function collectSensitivePathsFromFields(fields, prefix = "", output = []) {
+  for (const [key, value] of Object.entries(fields)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (DEFAULT_DONT_FLASH_FIELD_SET.has(key)) {
+      output.push(path);
+    }
+    if (isSchemaField(value)) {
+      if (value.definition.sensitive === true || value.definition.kind === "file") {
+        output.push(path);
+      }
+      continue;
+    }
+    if (isPlainObject(value)) {
+      collectSensitivePathsFromFields(value, path, output);
+    }
+  }
+  return output;
+}
+function collectSensitivePaths(schemaDefinition) {
+  if (!schemaDefinition) {
+    return [];
+  }
+  return collectSensitivePathsFromFields(schemaDefinition.fields);
+}
+function deletePath(root, path) {
+  const parts = path.split(".").filter(Boolean);
+  const leaf = parts.at(-1);
+  if (!leaf) {
+    return;
+  }
+  let cursor = root;
+  for (const part of parts.slice(0, -1)) {
+    if (!isPlainObject(cursor)) {
+      return;
+    }
+    cursor = cursor[part];
+  }
+  if (isPlainObject(cursor)) {
+    delete cursor[leaf];
+  }
+}
+function clearPath(root, path) {
+  const parts = path.split(".").filter(Boolean);
+  const leaf = parts.at(-1);
+  if (!leaf) {
+    return;
+  }
+  let cursor = root;
+  for (const part of parts.slice(0, -1)) {
+    if (!isPlainObject(cursor)) {
+      return;
+    }
+    cursor = cursor[part];
+  }
+  if (isPlainObject(cursor) && leaf in cursor) {
+    cursor[leaf] = "";
+  }
+}
+function sanitizePlainObject(values, sensitivePaths) {
+  if (!isPlainObject(values)) {
+    return values;
+  }
+  const output = structuredClone(values);
+  for (const field of DEFAULT_DONT_FLASH_FIELD_SET) {
+    delete output[field];
+  }
+  for (const path of sensitivePaths) {
+    deletePath(output, path);
+  }
+  return output;
+}
+function sanitizeFlashedInput(values, schemaDefinition) {
+  return sanitizePlainObject(values, collectSensitivePaths(schemaDefinition));
+}
+function clearSensitiveInputValues(values, schemaDefinition) {
+  if (!isPlainObject(values)) {
+    return values;
+  }
+  const mutableValues = values;
+  for (const field of DEFAULT_DONT_FLASH_FIELD_SET) {
+    if (field in mutableValues) {
+      mutableValues[field] = "";
+    }
+  }
+  for (const path of collectSensitivePaths(schemaDefinition)) {
+    clearPath(mutableValues, path);
+  }
+  return values;
+}
+var sensitiveInputInternals = {
+  collectSensitivePaths,
+  DEFAULT_DONT_FLASH_FIELDS
+};
+
+export {
+  normalizeStatus,
+  normalizeFailureInput,
+  normalizeFailureErrors,
+  sanitizeFlashedInput,
+  clearSensitiveInputValues,
+  sensitiveInputInternals
+};

package/dist/contracts-D1dERmQn.d.ts

@@ -0,0 +1,131 @@
+import { ValidationSchema, SchemaInputShape, ValidationErrorBag, InferSchemaData, FormLikeValidationInput } from '@holo-js/validation';
+import { FormSchema } from './schema.js';
+
+type FormFailureErrors = Readonly<Partial<Record<string, readonly string[]>>>;
+interface FormFailureOptions {
+    readonly status?: number;
+    readonly errors?: FormFailureErrors;
+}
+type FormFailureInput = number | FormFailureOptions | undefined;
+declare function normalizeStatus(value: number | undefined, fallback: number): number;
+
+type SensitiveSchema = Pick<ValidationSchema<SchemaInputShape>, 'fields'>;
+declare function collectSensitivePaths(schemaDefinition: SensitiveSchema | undefined): readonly string[];
+declare function sanitizeFlashedInput<TData>(values: Partial<TData> | TData, schemaDefinition?: SensitiveSchema): Partial<TData> | TData;
+declare const sensitiveInputInternals: {
+    collectSensitivePaths: typeof collectSensitivePaths;
+    DEFAULT_DONT_FLASH_FIELDS: readonly string[];
+};
+
+interface FormFailurePayload<TData> {
+    readonly ok: false;
+    readonly status: number;
+    readonly valid: false;
+    readonly values: Partial<TData>;
+    readonly errors: Record<string, readonly string[]>;
+    readonly retryAfterSeconds?: number;
+    readonly retryAt?: string;
+}
+interface FormSuccessPayload<TPayload = undefined> {
+    readonly ok: true;
+    readonly status: number;
+    readonly data: TPayload;
+}
+interface SerializedFormSubmission<TData> {
+    readonly ok?: false;
+    readonly valid: boolean;
+    readonly submitted: true;
+    readonly values: Partial<TData> | TData;
+    readonly errors: Record<string, readonly string[]>;
+}
+interface FormSecurityOptions {
+    readonly throttle?: string;
+    readonly bag?: string;
+}
+type RequestLikeHeaders = Headers | ReadonlyArray<readonly [string, string]> | Record<string, string | readonly string[] | undefined> | {
+    readonly get?: (name: string) => string | null | undefined;
+    readonly forEach?: (callback: (value: string, key: string) => void) => void;
+    readonly entries?: () => Iterable<readonly [string, string]>;
+};
+interface StructuredRequestLikeObject {
+    readonly method?: string;
+    readonly path?: string;
+    readonly url?: string | URL;
+    readonly headers?: RequestLikeHeaders;
+    readonly body?: unknown;
+}
+interface FormFailureMetadata {
+    readonly retryAfterSeconds?: number;
+    readonly retryAt?: string;
+}
+interface FormRequestLikeInput {
+    readonly method?: string;
+    readonly path?: string;
+    readonly url?: string | URL;
+    readonly headers?: RequestLikeHeaders;
+    readonly body?: unknown;
+    readonly req?: Request | {
+        readonly method?: string;
+        readonly url?: string;
+        readonly headers?: RequestLikeHeaders;
+        readonly body?: unknown;
+    };
+    readonly node?: {
+        readonly req?: {
+            readonly method?: string;
+            readonly url?: string;
+            readonly headers?: RequestLikeHeaders;
+            readonly body?: unknown;
+        };
+    };
+    readonly web?: {
+        readonly request?: Request | StructuredRequestLikeObject;
+    };
+}
+interface FormSubmissionSuccess<TData> {
+    readonly valid: true;
+    readonly submitted: true;
+    readonly data: TData;
+    readonly values: TData;
+    readonly errors: ValidationErrorBag<TData>;
+    serialize(): SerializedFormSubmission<TData>;
+    success(): FormSuccessPayload<undefined>;
+    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
+    fail(): FormFailurePayload<TData>;
+    fail(status?: number): FormFailurePayload<TData>;
+    fail(options: FormFailureOptions): FormFailurePayload<TData>;
+}
+interface FormSubmissionFailure<TData> {
+    readonly valid: false;
+    readonly submitted: true;
+    readonly data?: undefined;
+    readonly values: Partial<TData>;
+    readonly errors: ValidationErrorBag<TData>;
+    serialize(): SerializedFormSubmission<TData>;
+    success(): FormSuccessPayload<undefined>;
+    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
+    fail(): FormFailurePayload<TData>;
+    fail(status?: number): FormFailurePayload<TData>;
+    fail(options: FormFailureOptions): FormFailurePayload<TData>;
+}
+type FormSubmissionResult<TData> = FormSubmissionSuccess<TData> | FormSubmissionFailure<TData>;
+declare function serializeSubmissionState<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, schemaDefinition?: FormSchema): SerializedFormSubmission<TData>;
+declare function createSubmission<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, failureStatus?: number, schemaDefinition?: FormSchema, failureMetadata?: FormFailureMetadata): FormSubmissionResult<TData>;
+declare function createSuccessfulSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, data: InferSchemaData<TShape>): FormSubmissionSuccess<InferSchemaData<TShape>>;
+declare function createFailedSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, values: Partial<InferSchemaData<TShape>>, flattenedErrors: Record<string, readonly string[]>, status?: number, failureMetadata?: FormFailureMetadata): FormSubmissionFailure<InferSchemaData<TShape>>;
+declare function isRequestLikeHeaders(value: unknown): value is RequestLikeHeaders;
+declare function normalizeRequestHeaders(input: unknown): Headers;
+declare function normalizeRequestLikeInput(input: FormLikeValidationInput | FormRequestLikeInput | null | undefined): Request | undefined;
+declare function safeParse<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: FormSchema<TShape>, options?: FormSecurityOptions): Promise<FormSubmissionResult<InferSchemaData<TShape>>>;
+declare function validate<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: FormSchema<TShape>, options?: FormSecurityOptions): Promise<InferSchemaData<TShape>>;
+declare const formsInternals: {
+    createSubmission: typeof createSubmission;
+    isRequestLikeHeaders: typeof isRequestLikeHeaders;
+    normalizeRequestLikeInput: typeof normalizeRequestLikeInput;
+    normalizeStatus: typeof normalizeStatus;
+    normalizeRequestHeaders: typeof normalizeRequestHeaders;
+    sanitizeFlashedInput: typeof sanitizeFlashedInput;
+    serializeSubmissionState: typeof serializeSubmissionState;
+};
+
+export { type FormFailureErrors as F, type SerializedFormSubmission as S, type FormFailureInput as a, type FormFailureOptions as b, type FormFailurePayload as c, type FormRequestLikeInput as d, type FormSecurityOptions as e, type FormSubmissionFailure as f, type FormSubmissionResult as g, type FormSubmissionSuccess as h, type FormSuccessPayload as i, createFailedSubmission as j, createSuccessfulSubmission as k, formsInternals as l, sanitizeFlashedInput as m, sensitiveInputInternals as n, safeParse as s, validate as v };

package/dist/index.d.ts

@@ -1,102 +1,9 @@
-import { SchemaInputShape, ValidationSchema, InferSchemaData, ValidationErrorBag, FormLikeValidationInput } from '@holo-js/validation';
-export { ErrorTree, ErrorTreeNode, FieldDefinition, FieldRule, InferSchemaData, StandardSchemaV1, StandardSchemaV1Issue, StandardSchemaV1Props, StandardSchemaV1Result, ValidationErrorBag, ValidationFailure, ValidationResult, ValidationSchema, ValidationSuccess, WebFileLike, createErrorBag, defineSchema, field, parse, safeParse } from '@holo-js/validation';
+export { F as FormFailureErrors, a as FormFailureInput, b as FormFailureOptions, c as FormFailurePayload, d as FormRequestLikeInput, e as FormSecurityOptions, f as FormSubmissionFailure, g as FormSubmissionResult, h as FormSubmissionSuccess, i as FormSuccessPayload, S as SerializedFormSubmission, j as createFailedSubmission, k as createSuccessfulSubmission, l as formsInternals, s as safeParse, m as sanitizeFlashedInput, n as sensitiveInputInternals, v as validate } from './contracts-D1dERmQn.js';
+export { FormSchema, InferFormData, isFormSchema, schema } from './schema.js';
+export { DEFAULT_VALIDATION_BAG, ErrorTree, ErrorTreeNode, FieldDefinition, FieldRule, InferSchemaData, SerializedValidationException, StandardSchemaV1, StandardSchemaV1Issue, StandardSchemaV1Props, StandardSchemaV1Result, ValidationErrorBag, ValidationException, ValidationExceptionOptions, ValidationFailure, ValidationResult, ValidationSchema, ValidationSuccess, WebFileLike, createErrorBag, defineSchema, field, isValidationException, parse } from '@holo-js/validation';
 
-interface FormSchema<TShape extends SchemaInputShape = SchemaInputShape> extends ValidationSchema<TShape> {
-    readonly mode: 'form';
-    readonly fields: ValidationSchema<TShape>['fields'];
-    readonly $values?: Partial<InferSchemaData<TShape>>;
-}
-interface FormFailurePayload<TData> {
-    readonly ok: false;
-    readonly status: number;
-    readonly valid: false;
-    readonly values: Partial<TData>;
-    readonly errors: Record<string, readonly string[]>;
-}
-interface FormSuccessPayload<TPayload = undefined> {
-    readonly ok: true;
-    readonly status: number;
-    readonly data: TPayload;
-}
-interface SerializedFormSubmission<TData> {
-    readonly valid: boolean;
-    readonly submitted: true;
-    readonly values: Partial<TData> | TData;
-    readonly errors: Record<string, readonly string[]>;
-}
-interface FormSecurityOptions {
-    readonly csrf?: boolean;
-    readonly throttle?: string;
-}
-type RequestLikeHeaders = Headers | ReadonlyArray<readonly [string, string]> | Record<string, string | readonly string[] | undefined>;
-interface FormRequestLikeInput {
-    readonly method?: string;
-    readonly path?: string;
-    readonly url?: string | URL;
-    readonly headers?: RequestLikeHeaders;
-    readonly body?: unknown;
-    readonly req?: Request | {
-        readonly method?: string;
-        readonly url?: string;
-        readonly headers?: RequestLikeHeaders;
-        readonly body?: unknown;
-    };
-    readonly node?: {
-        readonly req?: {
-            readonly method?: string;
-            readonly url?: string;
-            readonly headers?: RequestLikeHeaders;
-            readonly body?: unknown;
-        };
-    };
-    readonly web?: {
-        readonly request?: Request;
-    };
-}
-interface FormSubmissionSuccess<TData> {
-    readonly valid: true;
-    readonly submitted: true;
-    readonly data: TData;
-    readonly values: TData;
-    readonly errors: ValidationErrorBag<TData>;
-    serialize(): SerializedFormSubmission<TData>;
-    success(): FormSuccessPayload<undefined>;
-    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
-    fail(status?: number): FormFailurePayload<TData>;
-}
-interface FormSubmissionFailure<TData> {
-    readonly valid: false;
-    readonly submitted: true;
-    readonly data?: undefined;
-    readonly values: Partial<TData>;
-    readonly errors: ValidationErrorBag<TData>;
-    serialize(): SerializedFormSubmission<TData>;
-    success(): FormSuccessPayload<undefined>;
-    success<TPayload>(payload: TPayload, status?: number): FormSuccessPayload<TPayload>;
-    fail(status?: number): FormFailurePayload<TData>;
-}
-type FormSubmissionResult<TData> = FormSubmissionSuccess<TData> | FormSubmissionFailure<TData>;
 declare class FormContractError extends Error {
     constructor(message: string);
 }
-declare function schema<TShape extends SchemaInputShape>(shapeOrSchema: TShape | ValidationSchema<TShape>): FormSchema<TShape>;
-declare function isFormSchema(value: unknown): value is FormSchema;
-declare function normalizeStatus(value: number | undefined, fallback: number): number;
-declare function serializeSubmissionState<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>): SerializedFormSubmission<TData>;
-declare function createSubmission<TData>(valid: boolean, values: Partial<TData> | TData, errors: ValidationErrorBag<TData>, failureStatus?: number): FormSubmissionResult<TData>;
-declare function createSuccessfulSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, data: InferSchemaData<TShape>): FormSubmissionSuccess<InferSchemaData<TShape>>;
-declare function createFailedSubmission<TShape extends SchemaInputShape>(schemaDefinition: FormSchema<TShape>, values: Partial<InferSchemaData<TShape>>, flattenedErrors: Record<string, readonly string[]>, status?: number): FormSubmissionFailure<InferSchemaData<TShape>>;
-declare function isRequestLikeHeaders(value: unknown): value is RequestLikeHeaders;
-declare function normalizeRequestHeaders(input: unknown): Headers;
-declare function normalizeRequestLikeInput(input: FormLikeValidationInput | FormRequestLikeInput | null | undefined): Request | undefined;
-declare function validate<TShape extends SchemaInputShape>(input: FormLikeValidationInput | FormRequestLikeInput, schemaDefinition: FormSchema<TShape>, options?: FormSecurityOptions): Promise<FormSubmissionResult<InferSchemaData<TShape>>>;
-declare const formsInternals: {
-    createSubmission: typeof createSubmission;
-    isRequestLikeHeaders: typeof isRequestLikeHeaders;
-    normalizeRequestLikeInput: typeof normalizeRequestLikeInput;
-    normalizeStatus: typeof normalizeStatus;
-    normalizeRequestHeaders: typeof normalizeRequestHeaders;
-    serializeSubmissionState: typeof serializeSubmissionState;
-};
 
-export { FormContractError, type FormFailurePayload, type FormRequestLikeInput, type FormSchema, type FormSecurityOptions, type FormSubmissionFailure, type FormSubmissionResult, type FormSubmissionSuccess, type FormSuccessPayload, type SerializedFormSubmission, createFailedSubmission, createSuccessfulSubmission, formsInternals, isFormSchema, schema, validate };
+export { FormContractError };