Compiled (unminified) | @remix-run/data-schema

schemas/libraries/@remix-run/data-schema/download_compiled/index/unminified.jscodeView FormattedView Formatted
Copy to clipboardCopy to clipboard

schemas/libraries/@remix-run/data-schema/download_compiled/index/unminified.jscodeView FormattedView Formatted
Copy to clipboardCopy to clipboard

schemas/libraries/@remix-run/data-schema/download_compiled/index/unminified.jscodeView FormattedView Formatted
Copy to clipboardCopy to clipboard

//#region ../node_modules/.pnpm/@remix-run+data-schema@1.0.0/node_modules/@remix-run/data-schema/dist/lib/schema.js
const builtinSchemas = /* @__PURE__ */ new WeakSet();
/**
* Creates a sync Standard Schema-compatible schema from a validation function.
*
* @param validator Validator that returns either a parsed value or validation issues.
* @returns A chainable schema object.
*/
function createSchema(validator) {
	let schema = {
		"~standard": {
			version: 1,
			vendor: "data-schema",
			validate(value, options) {
				return validator(value, {
					path: [],
					options,
					mutablePath: isBuiltinSchema(schema)
				});
			}
		},
		"~run"(value, context) {
			if (context.mutablePath) return validator(value, {
				path: [...context.path],
				options: context.options
			});
			return validator(value, context);
		},
		pipe(...checks) {
			if (checks.length === 0) return schema;
			return createDerivedSchema(schema, function validate(value, context) {
				let result = schema["~run"](value, context);
				if (result.issues) return result;
				for (let check of checks) if (!check.check(result.value)) {
					if (!check.code) return { issues: [createIssue(check.message ?? "Check failed", [...context.path])] };
					return { issues: [createIssueFromContext(context, {
						code: check.code,
						defaultMessage: check.message ?? "Check failed",
						input: result.value,
						values: check.values
					})] };
				}
				return result;
			});
		},
		refine(predicate, message) {
			return createDerivedSchema(schema, function validate(value, context) {
				let result = schema["~run"](value, context);
				if (result.issues) return result;
				if (!predicate(result.value)) {
					if (message !== void 0) return { issues: [createIssue(message, [...context.path])] };
					return { issues: [createIssueFromContext(context, {
						code: "refine.failed",
						defaultMessage: "Refinement failed",
						input: result.value
					})] };
				}
				return result;
			});
		},
		transform(transformer) {
			return createDerivedSchema(schema, function validate(value, context) {
				let result = schema["~run"](value, context);
				if (result.issues) return result;
				return { value: transformer(result.value) };
			});
		}
	};
	return schema;
}
function isBuiltinSchema(schema) {
	return builtinSchemas.has(schema);
}
function createBuiltinSchema(validator) {
	let schema = createSchema(validator);
	schema["~run"] = validator;
	builtinSchemas.add(schema);
	return schema;
}
function createDerivedSchema(source, validator) {
	return isBuiltinSchema(source) ? createBuiltinSchema(validator) : createSchema(validator);
}
function runAtPath(schema, value, context, key) {
	if (context.mutablePath !== true || !Array.isArray(context.path)) {
		let childContext = {
			path: withPath(context.path, key),
			options: context.options,
			mutablePath: false
		};
		return schema["~run"](value, childContext);
	}
	context.path.push(key);
	try {
		return schema["~run"](value, context);
	} finally {
		context.path.pop();
	}
}
function shouldAbortEarly(options) {
	let libraryAbortEarly = options?.libraryOptions?.abortEarly;
	let abortEarly = options?.abortEarly ?? libraryAbortEarly;
	return Boolean(abortEarly);
}
function withPath(path, key) {
	return path.length === 0 ? [key] : [...path, key];
}
function getErrorMap(options) {
	let libraryErrorMap = options?.libraryOptions?.errorMap;
	if (typeof options?.errorMap === "function") return options.errorMap;
	if (typeof libraryErrorMap === "function") return libraryErrorMap;
}
function getLocale(options) {
	let libraryLocale = options?.libraryOptions?.locale;
	if (typeof options?.locale === "string") return options.locale;
	if (typeof libraryLocale === "string") return libraryLocale;
}
function resolveIssueMessage(options, context) {
	let errorMap = getErrorMap(options);
	if (!errorMap) return context.defaultMessage;
	return errorMap(context) ?? context.defaultMessage;
}
function createIssueFromContext(context, descriptor) {
	let path = [...descriptor.path ?? context.path];
	return createIssue(resolveIssueMessage(context.options, {
		code: descriptor.code,
		defaultMessage: descriptor.defaultMessage,
		path,
		values: descriptor.values,
		input: descriptor.input,
		locale: getLocale(context.options)
	}), path);
}
/**
* Creates a Standard Schema issue object.
*
* @param message Human-readable validation message.
* @param path Optional issue path within the input value.
* @returns A Standard Schema issue.
*/
function createIssue(message, path) {
	return !path || path.length === 0 ? { message } : {
		message,
		path
	};
}
/**
* Creates a Standard Schema failure result with a single issue.
*
* @param message Human-readable validation message.
* @param path Optional issue path within the input value.
* @param options Optional issue metadata used for localized error mapping.
* @param options.code Optional error code passed to the error map.
* @param options.values Optional values passed to the error map.
* @param options.input Optional input value passed to the error map.
* @param options.parseOptions Optional parse options used for localization and error mapping.
* @returns A failure result containing one issue.
*/
function fail(message, path, options) {
	if (!options?.code) return { issues: [createIssue(message, path)] };
	path = path && [...path];
	return { issues: [createIssue(resolveIssueMessage(options.parseOptions, {
		code: options.code,
		defaultMessage: message,
		path,
		values: options.values,
		input: options.input,
		locale: getLocale(options.parseOptions)
	}), path)] };
}
/**
* Create a schema that validates an array by validating each element with `elementSchema`.
*
* @param elementSchema The schema to validate each element
* @returns A schema that produces an array of validated outputs
*/
function array(elementSchema) {
	return createBuiltinSchema(function validate(value, context) {
		if (!Array.isArray(value)) return fail("Expected array", context.path, {
			code: "type.array",
			input: value,
			parseOptions: context.options
		});
		let abortEarly = shouldAbortEarly(context.options);
		let issues = [];
		let outputValues = new Array(value.length);
		let index = 0;
		for (let item of value) {
			let result = runAtPath(elementSchema, item, context, index);
			if (result.issues) {
				if (abortEarly) return result;
				issues.push(...result.issues);
			} else outputValues[index] = result.value;
			index += 1;
		}
		if (issues.length > 0) return { issues };
		outputValues.length = index;
		return { value: outputValues };
	});
}
/**
* Create a schema that accepts one of the given values using strict equality (`===`).
*
* @param values The allowed values
* @returns A schema that produces the union of allowed value types
*/
function enum_(values) {
	return createBuiltinSchema(function validate(value, context) {
		for (let allowed of values) if (value === allowed) return { value };
		return fail("Expected one of: " + values.map(String).join(", "), context.path, {
			code: "enum.invalid_value",
			input: value,
			values: { values: [...values] },
			parseOptions: context.options
		});
	});
}
/**
* Create a schema that validates a value is an instance of a class.
*
* @param constructor The class constructor to check against
* @returns A schema that produces the instance type
*/
function instanceof_(constructor) {
	return createBuiltinSchema(function validate(value, context) {
		if (!(value instanceof constructor)) return fail("Expected instance of " + constructor.name, context.path, {
			code: "instanceof.invalid_type",
			input: value,
			values: { constructorName: constructor.name },
			parseOptions: context.options
		});
		return { value };
	});
}
/**
* Allow `null` as an input value, short-circuiting validation when `null` is provided.
*
* @param schema The wrapped schema
* @returns A schema that accepts `null` in addition to the wrapped schema
*/
function nullable(schema) {
	return createBuiltinSchema(function validate(value, context) {
		if (value === null) return { value: null };
		return schema["~run"](value, context);
	});
}
/**
* Create a schema that accepts finite numbers (excluding `NaN` and `Infinity`).
*
* @returns A schema that produces a `number`
*/
function number() {
	return createBuiltinSchema(function validate(value, context) {
		if (typeof value !== "number" || !Number.isFinite(value)) return fail("Expected number", context.path, {
			code: "type.number",
			input: value,
			parseOptions: context.options
		});
		return { value };
	});
}
/**
* Create a schema that validates an object with a fixed shape.
*
* By default, unknown keys are stripped. You can change this via `options.unknownKeys`.
*
* @param shape A mapping of keys to schemas
* @param options Controls unknown key behavior
* @returns A schema that produces a typed object matching the shape
*/
function object(shape, options) {
	return createBuiltinSchema(function validate(value, context) {
		if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("Expected object", context.path, {
			code: "type.object",
			input: value,
			parseOptions: context.options
		});
		let abortEarly = shouldAbortEarly(context.options);
		let issues = [];
		let outputValues = {};
		let input = value;
		let unknownKeys = options?.unknownKeys ?? "strip";
		for (let key of Object.keys(shape)) {
			let result = runAtPath(shape[key], input[key], context, key);
			if (result.issues) {
				if (abortEarly) return result;
				issues.push(...result.issues);
			} else if (Object.prototype.hasOwnProperty.call(input, key) || result.value !== void 0) outputValues[key] = result.value;
		}
		if (unknownKeys === "passthrough" || unknownKeys === "error") for (let key in input) {
			if (!Object.prototype.hasOwnProperty.call(input, key)) continue;
			if (Object.prototype.hasOwnProperty.call(shape, key)) continue;
			if (unknownKeys === "passthrough") outputValues[key] = input[key];
			else {
				let issue = createIssueFromContext(context, {
					code: "object.unknown_key",
					defaultMessage: "Unknown key",
					input: input[key],
					path: withPath(context.path, key),
					values: { key }
				});
				if (abortEarly) return { issues: [issue] };
				issues.push(issue);
			}
		}
		if (issues.length > 0) return { issues };
		return { value: outputValues };
	});
}
/**
* Create a schema that accepts strings.
*
* @returns A schema that produces a `string`
*/
function string() {
	return createBuiltinSchema(function validate(value, context) {
		if (typeof value !== "string") return fail("Expected string", context.path, {
			code: "type.string",
			input: value,
			parseOptions: context.options
		});
		return { value };
	});
}
/**
* Error thrown by {@link parse} when validation fails.
*/
var ValidationError = class extends Error {
	/**
	* The validation issues produced by the schema.
	*/
	issues;
	/**
	* @param issues The issues produced by schema validation
	* @param message Optional error message (defaults to "Validation failed")
	*/
	constructor(issues, message = "Validation failed") {
		super(message);
		this.name = "ValidationError";
		this.issues = issues;
	}
};
/**
* Validate a value and return the typed output or throw a {@link ValidationError}.
*
* @param schema The schema to validate against
* @param value The value to validate
* @param options Validation options
* @returns The validated output value
* @throws {ValidationError} If validation fails
*/
function parse(schema, value, options) {
	let result = schema["~standard"].validate(value, options);
	if (result.issues) throw new ValidationError(result.issues);
	return result.value;
}
//#endregion
//#region ../node_modules/.pnpm/@remix-run+data-schema@1.0.0/node_modules/@remix-run/data-schema/dist/lib/checks.js
/**
* Require a string to be at least `length` characters long.
*
* @param length The minimum number of characters
* @returns A {@link Check} that enforces the minimum length
*/
function minLength(length) {
	return {
		check(value) {
			return value.length >= length;
		},
		code: "string.min_length",
		values: { min: length },
		message: "Expected at least " + String(length) + " characters"
	};
}
/**
* Require a string to be at most `length` characters long.
*
* @param length The maximum number of characters
* @returns A {@link Check} that enforces the maximum length
*/
function maxLength(length) {
	return {
		check(value) {
			return value.length <= length;
		},
		code: "string.max_length",
		values: { max: length },
		message: "Expected at most " + String(length) + " characters"
	};
}
/**
* Require a string to be a valid URL.
*
* @returns A {@link Check} that validates URL-like strings
*/
function url() {
	return {
		check(value) {
			try {
				new URL(value);
				return true;
			} catch {
				return false;
			}
		},
		code: "string.url",
		message: "Expected valid URL"
	};
}
/**
* Require a number to be greater than or equal to `limit`.
*
* @param limit The inclusive minimum value
* @returns A {@link Check} that enforces the lower bound
*/
function min(limit) {
	return {
		check(value) {
			return value >= limit;
		},
		code: "number.min",
		values: { min: limit },
		message: "Expected number greater than or equal to " + String(limit)
	};
}
/**
* Require a number to be less than or equal to `limit`.
*
* @param limit The inclusive maximum value
* @returns A {@link Check} that enforces the upper bound
*/
function max(limit) {
	return {
		check(value) {
			return value <= limit;
		},
		code: "number.max",
		values: { max: limit },
		message: "Expected number less than or equal to " + String(limit)
	};
}
//#endregion
//#region ../schemas/libraries/@remix-run/data-schema/download/index.ts
const imageSchema = object({
	id: number(),
	created: instanceof_(Date),
	title: string().pipe(minLength(1), maxLength(100)),
	type: enum_(["jpg", "png"]),
	size: number(),
	url: string().pipe(url())
});
const ratingSchema = object({
	id: number(),
	stars: number().pipe(min(1), max(5)),
	title: string().pipe(minLength(1), maxLength(100)),
	text: string().pipe(minLength(1), maxLength(1e3)),
	images: array(imageSchema)
});
parse(object({
	id: number(),
	created: instanceof_(Date),
	title: string().pipe(minLength(1), maxLength(100)),
	brand: string().pipe(minLength(1), maxLength(30)),
	description: string().pipe(minLength(1), maxLength(500)),
	price: number().pipe(min(1), max(1e4)),
	discount: nullable(number().pipe(min(1), max(100))),
	quantity: number().pipe(min(0), max(10)),
	tags: array(string().pipe(minLength(1), maxLength(30))),
	images: array(imageSchema),
	ratings: array(ratingSchema)
}), {});
//#endregion

Preferences

Style

Theme

NPM browser

Code ligatures