strapi-plugin-publisher
Version:
A plugin for Strapi Headless CMS that provides the ability to schedule publishing for any content type.
1,612 lines (1,611 loc) • 74.9 kB
JavaScript
"use strict";
const has = require("lodash/has");
const mapValues = require("lodash/mapValues");
const snakeCase = require("lodash/snakeCase");
const camelCase = require("lodash/camelCase");
const mapKeys = require("lodash/mapKeys");
const strapi$2 = require("@strapi/strapi");
const utils = require("@strapi/utils");
const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
const has__default = /* @__PURE__ */ _interopDefault(has);
const mapValues__default = /* @__PURE__ */ _interopDefault(mapValues);
const snakeCase__default = /* @__PURE__ */ _interopDefault(snakeCase);
const camelCase__default = /* @__PURE__ */ _interopDefault(camelCase);
const mapKeys__default = /* @__PURE__ */ _interopDefault(mapKeys);
const $schema = "https://json.schemastore.org/package";
const name = "strapi-plugin-publisher";
const version = "2.0.2";
const description = "A plugin for Strapi Headless CMS that provides the ability to schedule publishing for any content type.";
const scripts = {
lint: "eslint . --fix",
format: "prettier --write **/*.{ts,js,json,yml}",
build: "strapi-plugin build",
watch: "strapi-plugin watch",
"watch:link": "strapi-plugin watch:link"
};
const exports$1 = {
"./strapi-admin": {
source: "./admin/src/index.ts",
"import": "./dist/admin/index.mjs",
require: "./dist/admin/index.js",
"default": "./dist/admin/index.js"
},
"./strapi-server": {
source: "./server/index.js",
"import": "./dist/server/index.mjs",
require: "./dist/server/index.js",
"default": "./dist/server/index.js"
},
"./package.json": "./package.json"
};
const author = {
name: "@ComfortablyCoding",
url: "https://github.com/ComfortablyCoding"
};
const maintainers = [
{
name: "@PluginPal",
url: "https://github.com/PluginPal"
}
];
const homepage = "https://github.com/PluginPal/strapi-plugin-publisher#readme";
const repository = {
type: "git",
url: "https://github.com/PluginPal/strapi-plugin-publisher.git"
};
const bugs = {
url: "https://github.com/PluginPal/strapi-plugin-publisher/issues"
};
const dependencies = {
lodash: "^4.17.21",
"prop-types": "^15.8.1",
"react-intl": "^6.6.2",
"react-query": "^3.39.3"
};
const devDependencies = {
"@babel/core": "^7.23.3",
"@babel/eslint-parser": "^7.23.3",
"@babel/preset-react": "^7.23.3",
"@strapi/sdk-plugin": "^5.2.7",
"@strapi/strapi": "^5.2.0",
eslint: "^8.53.0",
"eslint-config-prettier": "^9.0.0",
"eslint-plugin-node": "^11.1.0",
"eslint-plugin-react": "^7.33.2",
prettier: "^3.1.0",
react: "^18.2.0",
"react-dom": "^18.2.0",
"react-router-dom": "^6.0.0",
"styled-components": "^6.0.0"
};
const peerDependencies = {
"@strapi/design-system": "^2.0.0-rc.11",
"@strapi/icons": "^2.0.0-rc.11",
"@strapi/strapi": "^5.2.0",
"@strapi/utils": "^5.2.0",
react: "^17.0.0 || ^18.0.0",
"react-router-dom": "^6.0.0",
"styled-components": "^6.0.0"
};
const strapi$1 = {
displayName: "Publisher",
name: "publisher",
description: "A plugin for Strapi Headless CMS that provides the ability to schedule publishing for any content type.",
kind: "plugin"
};
const engines = {
node: ">=18.0.0 <=22.x.x",
npm: ">=6.0.0"
};
const keywords = [
"strapi",
"strapi-plugin",
"plugin",
"strapi plugin",
"publishing",
"schedule publish"
];
const license = "MIT";
const pluginPkg = {
$schema,
name,
version,
description,
scripts,
exports: exports$1,
author,
maintainers,
homepage,
repository,
bugs,
dependencies,
devDependencies,
peerDependencies,
strapi: strapi$1,
engines,
keywords,
license
};
const pluginId = pluginPkg.strapi.name;
const getPluginService = (name2) => strapi.plugin(pluginId).service(name2);
const registerCronTasks = ({ strapi: strapi2 }) => {
const settings = getPluginService("settingsService").get();
strapi2.cron.add({
publisherCronTask: {
options: settings.actions.syncFrequency,
task: async () => {
const records = await getPluginService("action").find({
filters: {
executeAt: {
$lte: new Date(Date.now())
}
}
});
for (const record of records.results) {
getPluginService("publicationService").toggle(record, record.mode);
}
}
}
});
};
const bootstrap = ({ strapi: strapi2 }) => {
registerCronTasks({ strapi: strapi2 });
};
var map;
try {
map = Map;
} catch (_) {
}
var set;
try {
set = Set;
} catch (_) {
}
function baseClone(src, circulars, clones) {
if (!src || typeof src !== "object" || typeof src === "function") {
return src;
}
if (src.nodeType && "cloneNode" in src) {
return src.cloneNode(true);
}
if (src instanceof Date) {
return new Date(src.getTime());
}
if (src instanceof RegExp) {
return new RegExp(src);
}
if (Array.isArray(src)) {
return src.map(clone);
}
if (map && src instanceof map) {
return new Map(Array.from(src.entries()));
}
if (set && src instanceof set) {
return new Set(Array.from(src.values()));
}
if (src instanceof Object) {
circulars.push(src);
var obj = Object.create(src);
clones.push(obj);
for (var key in src) {
var idx = circulars.findIndex(function(i) {
return i === src[key];
});
obj[key] = idx > -1 ? clones[idx] : baseClone(src[key], circulars, clones);
}
return obj;
}
return src;
}
function clone(src) {
return baseClone(src, [], []);
}
const toString = Object.prototype.toString;
const errorToString = Error.prototype.toString;
const regExpToString = RegExp.prototype.toString;
const symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
function printNumber(val) {
if (val != +val) return "NaN";
const isNegativeZero = val === 0 && 1 / val < 0;
return isNegativeZero ? "-0" : "" + val;
}
function printSimpleValue(val, quoteStrings = false) {
if (val == null || val === true || val === false) return "" + val;
const typeOf = typeof val;
if (typeOf === "number") return printNumber(val);
if (typeOf === "string") return quoteStrings ? `"${val}"` : val;
if (typeOf === "function") return "[Function " + (val.name || "anonymous") + "]";
if (typeOf === "symbol") return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
const tag = toString.call(val).slice(8, -1);
if (tag === "Date") return isNaN(val.getTime()) ? "" + val : val.toISOString(val);
if (tag === "Error" || val instanceof Error) return "[" + errorToString.call(val) + "]";
if (tag === "RegExp") return regExpToString.call(val);
return null;
}
function printValue(value, quoteStrings) {
let result = printSimpleValue(value, quoteStrings);
if (result !== null) return result;
return JSON.stringify(value, function(key, value2) {
let result2 = printSimpleValue(this[key], quoteStrings);
if (result2 !== null) return result2;
return value2;
}, 2);
}
let mixed = {
default: "${path} is invalid",
required: "${path} is a required field",
oneOf: "${path} must be one of the following values: ${values}",
notOneOf: "${path} must not be one of the following values: ${values}",
notType: ({
path,
type,
value,
originalValue
}) => {
let isCast = originalValue != null && originalValue !== value;
let msg = `${path} must be a \`${type}\` type, but the final value was: \`${printValue(value, true)}\`` + (isCast ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : ".");
if (value === null) {
msg += `
If "null" is intended as an empty value be sure to mark the schema as \`.nullable()\``;
}
return msg;
},
defined: "${path} must be defined"
};
let string = {
length: "${path} must be exactly ${length} characters",
min: "${path} must be at least ${min} characters",
max: "${path} must be at most ${max} characters",
matches: '${path} must match the following: "${regex}"',
email: "${path} must be a valid email",
url: "${path} must be a valid URL",
uuid: "${path} must be a valid UUID",
trim: "${path} must be a trimmed string",
lowercase: "${path} must be a lowercase string",
uppercase: "${path} must be a upper case string"
};
let number = {
min: "${path} must be greater than or equal to ${min}",
max: "${path} must be less than or equal to ${max}",
lessThan: "${path} must be less than ${less}",
moreThan: "${path} must be greater than ${more}",
positive: "${path} must be a positive number",
negative: "${path} must be a negative number",
integer: "${path} must be an integer"
};
let date = {
min: "${path} field must be later than ${min}",
max: "${path} field must be at earlier than ${max}"
};
let boolean = {
isValue: "${path} field must be ${value}"
};
let object = {
noUnknown: "${path} field has unspecified keys: ${unknown}"
};
let array = {
min: "${path} field must have at least ${min} items",
max: "${path} field must have less than or equal to ${max} items",
length: "${path} must be have ${length} items"
};
Object.assign(/* @__PURE__ */ Object.create(null), {
mixed,
string,
number,
date,
object,
array,
boolean
});
const isSchema = (obj) => obj && obj.__isYupSchema__;
class Condition {
constructor(refs, options) {
this.refs = refs;
this.refs = refs;
if (typeof options === "function") {
this.fn = options;
return;
}
if (!has__default.default(options, "is")) throw new TypeError("`is:` is required for `when()` conditions");
if (!options.then && !options.otherwise) throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
let {
is,
then,
otherwise
} = options;
let check = typeof is === "function" ? is : (...values) => values.every((value) => value === is);
this.fn = function(...args) {
let options2 = args.pop();
let schema = args.pop();
let branch = check(...args) ? then : otherwise;
if (!branch) return void 0;
if (typeof branch === "function") return branch(schema);
return schema.concat(branch.resolve(options2));
};
}
resolve(base, options) {
let values = this.refs.map((ref) => ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context));
let schema = this.fn.apply(base, values.concat(base, options));
if (schema === void 0 || schema === base) return base;
if (!isSchema(schema)) throw new TypeError("conditions must return a schema object");
return schema.resolve(options);
}
}
function toArray(value) {
return value == null ? [] : [].concat(value);
}
function _extends$4() {
_extends$4 = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends$4.apply(this, arguments);
}
let strReg = /\$\{\s*(\w+)\s*\}/g;
class ValidationError extends Error {
static formatError(message, params) {
const path = params.label || params.path || "this";
if (path !== params.path) params = _extends$4({}, params, {
path
});
if (typeof message === "string") return message.replace(strReg, (_, key) => printValue(params[key]));
if (typeof message === "function") return message(params);
return message;
}
static isError(err) {
return err && err.name === "ValidationError";
}
constructor(errorOrErrors, value, field, type) {
super();
this.name = "ValidationError";
this.value = value;
this.path = field;
this.type = type;
this.errors = [];
this.inner = [];
toArray(errorOrErrors).forEach((err) => {
if (ValidationError.isError(err)) {
this.errors.push(...err.errors);
this.inner = this.inner.concat(err.inner.length ? err.inner : err);
} else {
this.errors.push(err);
}
});
this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
if (Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);
}
}
const once = (cb) => {
let fired = false;
return (...args) => {
if (fired) return;
fired = true;
cb(...args);
};
};
function runTests(options, cb) {
let {
endEarly,
tests,
args,
value,
errors,
sort,
path
} = options;
let callback = once(cb);
let count = tests.length;
const nestedErrors = [];
errors = errors ? errors : [];
if (!count) return errors.length ? callback(new ValidationError(errors, value, path)) : callback(null, value);
for (let i = 0; i < tests.length; i++) {
const test = tests[i];
test(args, function finishTestRun(err) {
if (err) {
if (!ValidationError.isError(err)) {
return callback(err, value);
}
if (endEarly) {
err.value = value;
return callback(err, value);
}
nestedErrors.push(err);
}
if (--count <= 0) {
if (nestedErrors.length) {
if (sort) nestedErrors.sort(sort);
if (errors.length) nestedErrors.push(...errors);
errors = nestedErrors;
}
if (errors.length) {
callback(new ValidationError(errors, value, path), value);
return;
}
callback(null, value);
}
});
}
}
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
function Cache(maxSize) {
this._maxSize = maxSize;
this.clear();
}
Cache.prototype.clear = function() {
this._size = 0;
this._values = /* @__PURE__ */ Object.create(null);
};
Cache.prototype.get = function(key) {
return this._values[key];
};
Cache.prototype.set = function(key, value) {
this._size >= this._maxSize && this.clear();
if (!(key in this._values)) this._size++;
return this._values[key] = value;
};
var SPLIT_REGEX = /[^.^\]^[]+|(?=\[\]|\.\.)/g, DIGIT_REGEX = /^\d+$/, LEAD_DIGIT_REGEX = /^\d/, SPEC_CHAR_REGEX = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g, CLEAN_QUOTES_REGEX = /^\s*(['"]?)(.*?)(\1)\s*$/, MAX_CACHE_SIZE = 512;
var pathCache = new Cache(MAX_CACHE_SIZE), setCache = new Cache(MAX_CACHE_SIZE), getCache = new Cache(MAX_CACHE_SIZE);
var propertyExpr = {
Cache,
split,
normalizePath,
setter: function(path) {
var parts = normalizePath(path);
return setCache.get(path) || setCache.set(path, function setter(obj, value) {
var index2 = 0;
var len = parts.length;
var data = obj;
while (index2 < len - 1) {
var part = parts[index2];
if (part === "__proto__" || part === "constructor" || part === "prototype") {
return obj;
}
data = data[parts[index2++]];
}
data[parts[index2]] = value;
});
},
getter: function(path, safe) {
var parts = normalizePath(path);
return getCache.get(path) || getCache.set(path, function getter(data) {
var index2 = 0, len = parts.length;
while (index2 < len) {
if (data != null || !safe) data = data[parts[index2++]];
else return;
}
return data;
});
},
join: function(segments) {
return segments.reduce(function(path, part) {
return path + (isQuoted(part) || DIGIT_REGEX.test(part) ? "[" + part + "]" : (path ? "." : "") + part);
}, "");
},
forEach: function(path, cb, thisArg) {
forEach(Array.isArray(path) ? path : split(path), cb, thisArg);
}
};
function normalizePath(path) {
return pathCache.get(path) || pathCache.set(
path,
split(path).map(function(part) {
return part.replace(CLEAN_QUOTES_REGEX, "$2");
})
);
}
function split(path) {
return path.match(SPLIT_REGEX) || [""];
}
function forEach(parts, iter, thisArg) {
var len = parts.length, part, idx, isArray, isBracket;
for (idx = 0; idx < len; idx++) {
part = parts[idx];
if (part) {
if (shouldBeQuoted(part)) {
part = '"' + part + '"';
}
isBracket = isQuoted(part);
isArray = !isBracket && /^\d+$/.test(part);
iter.call(thisArg, part, isBracket, isArray, idx, parts);
}
}
}
function isQuoted(str) {
return typeof str === "string" && str && ["'", '"'].indexOf(str.charAt(0)) !== -1;
}
function hasLeadingNumber(part) {
return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX);
}
function hasSpecialChars(part) {
return SPEC_CHAR_REGEX.test(part);
}
function shouldBeQuoted(part) {
return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part));
}
const prefixes = {
context: "$",
value: "."
};
class Reference {
constructor(key, options = {}) {
if (typeof key !== "string") throw new TypeError("ref must be a string, got: " + key);
this.key = key.trim();
if (key === "") throw new TypeError("ref must be a non-empty string");
this.isContext = this.key[0] === prefixes.context;
this.isValue = this.key[0] === prefixes.value;
this.isSibling = !this.isContext && !this.isValue;
let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : "";
this.path = this.key.slice(prefix.length);
this.getter = this.path && propertyExpr.getter(this.path, true);
this.map = options.map;
}
getValue(value, parent, context) {
let result = this.isContext ? context : this.isValue ? value : parent;
if (this.getter) result = this.getter(result || {});
if (this.map) result = this.map(result);
return result;
}
/**
*
* @param {*} value
* @param {Object} options
* @param {Object=} options.context
* @param {Object=} options.parent
*/
cast(value, options) {
return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
}
resolve() {
return this;
}
describe() {
return {
type: "ref",
key: this.key
};
}
toString() {
return `Ref(${this.key})`;
}
static isRef(value) {
return value && value.__isYupRef;
}
}
Reference.prototype.__isYupRef = true;
function _extends$3() {
_extends$3 = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends$3.apply(this, arguments);
}
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
function createValidation(config2) {
function validate(_ref, cb) {
let {
value,
path = "",
label,
options,
originalValue,
sync
} = _ref, rest = _objectWithoutPropertiesLoose(_ref, ["value", "path", "label", "options", "originalValue", "sync"]);
const {
name: name2,
test,
params,
message
} = config2;
let {
parent,
context
} = options;
function resolve(item) {
return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
}
function createError(overrides = {}) {
const nextParams = mapValues__default.default(_extends$3({
value,
originalValue,
label,
path: overrides.path || path
}, params, overrides.params), resolve);
const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name2);
error.params = nextParams;
return error;
}
let ctx = _extends$3({
path,
parent,
type: name2,
createError,
resolve,
options,
originalValue
}, rest);
if (!sync) {
try {
Promise.resolve(test.call(ctx, value, ctx)).then((validOrError) => {
if (ValidationError.isError(validOrError)) cb(validOrError);
else if (!validOrError) cb(createError());
else cb(null, validOrError);
});
} catch (err) {
cb(err);
}
return;
}
let result;
try {
var _ref2;
result = test.call(ctx, value, ctx);
if (typeof ((_ref2 = result) == null ? void 0 : _ref2.then) === "function") {
throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
}
} catch (err) {
cb(err);
return;
}
if (ValidationError.isError(result)) cb(result);
else if (!result) cb(createError());
else cb(null, result);
}
validate.OPTIONS = config2;
return validate;
}
let trim = (part) => part.substr(0, part.length - 1).substr(1);
function getIn(schema, path, value, context = value) {
let parent, lastPart, lastPartDebug;
if (!path) return {
parent,
parentPath: path,
schema
};
propertyExpr.forEach(path, (_part, isBracket, isArray) => {
let part = isBracket ? trim(_part) : _part;
schema = schema.resolve({
context,
parent,
value
});
if (schema.innerType) {
let idx = isArray ? parseInt(part, 10) : 0;
if (value && idx >= value.length) {
throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. because there is no value at that index. `);
}
parent = value;
value = value && value[idx];
schema = schema.innerType;
}
if (!isArray) {
if (!schema.fields || !schema.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema._type}")`);
parent = value;
value = value && value[part];
schema = schema.fields[part];
}
lastPart = part;
lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
});
return {
schema,
parent,
parentPath: lastPart
};
}
class ReferenceSet {
constructor() {
this.list = /* @__PURE__ */ new Set();
this.refs = /* @__PURE__ */ new Map();
}
get size() {
return this.list.size + this.refs.size;
}
describe() {
const description2 = [];
for (const item of this.list) description2.push(item);
for (const [, ref] of this.refs) description2.push(ref.describe());
return description2;
}
toArray() {
return Array.from(this.list).concat(Array.from(this.refs.values()));
}
add(value) {
Reference.isRef(value) ? this.refs.set(value.key, value) : this.list.add(value);
}
delete(value) {
Reference.isRef(value) ? this.refs.delete(value.key) : this.list.delete(value);
}
has(value, resolve) {
if (this.list.has(value)) return true;
let item, values = this.refs.values();
while (item = values.next(), !item.done) if (resolve(item.value) === value) return true;
return false;
}
clone() {
const next = new ReferenceSet();
next.list = new Set(this.list);
next.refs = new Map(this.refs);
return next;
}
merge(newItems, removeItems) {
const next = this.clone();
newItems.list.forEach((value) => next.add(value));
newItems.refs.forEach((value) => next.add(value));
removeItems.list.forEach((value) => next.delete(value));
removeItems.refs.forEach((value) => next.delete(value));
return next;
}
}
function _extends$2() {
_extends$2 = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends$2.apply(this, arguments);
}
class BaseSchema {
constructor(options) {
this.deps = [];
this.conditions = [];
this._whitelist = new ReferenceSet();
this._blacklist = new ReferenceSet();
this.exclusiveTests = /* @__PURE__ */ Object.create(null);
this.tests = [];
this.transforms = [];
this.withMutation(() => {
this.typeError(mixed.notType);
});
this.type = (options == null ? void 0 : options.type) || "mixed";
this.spec = _extends$2({
strip: false,
strict: false,
abortEarly: true,
recursive: true,
nullable: false,
presence: "optional"
}, options == null ? void 0 : options.spec);
}
// TODO: remove
get _type() {
return this.type;
}
_typeCheck(_value) {
return true;
}
clone(spec) {
if (this._mutate) {
if (spec) Object.assign(this.spec, spec);
return this;
}
const next = Object.create(Object.getPrototypeOf(this));
next.type = this.type;
next._typeError = this._typeError;
next._whitelistError = this._whitelistError;
next._blacklistError = this._blacklistError;
next._whitelist = this._whitelist.clone();
next._blacklist = this._blacklist.clone();
next.exclusiveTests = _extends$2({}, this.exclusiveTests);
next.deps = [...this.deps];
next.conditions = [...this.conditions];
next.tests = [...this.tests];
next.transforms = [...this.transforms];
next.spec = clone(_extends$2({}, this.spec, spec));
return next;
}
label(label) {
var next = this.clone();
next.spec.label = label;
return next;
}
meta(...args) {
if (args.length === 0) return this.spec.meta;
let next = this.clone();
next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
return next;
}
// withContext<TContext extends AnyObject>(): BaseSchema<
// TCast,
// TContext,
// TOutput
// > {
// return this as any;
// }
withMutation(fn) {
let before = this._mutate;
this._mutate = true;
let result = fn(this);
this._mutate = before;
return result;
}
concat(schema) {
if (!schema || schema === this) return this;
if (schema.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
let base = this;
let combined = schema.clone();
const mergedSpec = _extends$2({}, base.spec, combined.spec);
combined.spec = mergedSpec;
combined._typeError || (combined._typeError = base._typeError);
combined._whitelistError || (combined._whitelistError = base._whitelistError);
combined._blacklistError || (combined._blacklistError = base._blacklistError);
combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
combined.tests = base.tests;
combined.exclusiveTests = base.exclusiveTests;
combined.withMutation((next) => {
schema.tests.forEach((fn) => {
next.test(fn.OPTIONS);
});
});
return combined;
}
isType(v) {
if (this.spec.nullable && v === null) return true;
return this._typeCheck(v);
}
resolve(options) {
let schema = this;
if (schema.conditions.length) {
let conditions = schema.conditions;
schema = schema.clone();
schema.conditions = [];
schema = conditions.reduce((schema2, condition) => condition.resolve(schema2, options), schema);
schema = schema.resolve(options);
}
return schema;
}
/**
*
* @param {*} value
* @param {Object} options
* @param {*=} options.parent
* @param {*=} options.context
*/
cast(value, options = {}) {
let resolvedSchema = this.resolve(_extends$2({
value
}, options));
let result = resolvedSchema._cast(value, options);
if (value !== void 0 && options.assert !== false && resolvedSchema.isType(result) !== true) {
let formattedValue = printValue(value);
let formattedResult = printValue(result);
throw new TypeError(`The value of ${options.path || "field"} could not be cast to a value that satisfies the schema type: "${resolvedSchema._type}".
attempted value: ${formattedValue}
` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ""));
}
return result;
}
_cast(rawValue, _options) {
let value = rawValue === void 0 ? rawValue : this.transforms.reduce((value2, fn) => fn.call(this, value2, rawValue, this), rawValue);
if (value === void 0) {
value = this.getDefault();
}
return value;
}
_validate(_value, options = {}, cb) {
let {
sync,
path,
from = [],
originalValue = _value,
strict = this.spec.strict,
abortEarly = this.spec.abortEarly
} = options;
let value = _value;
if (!strict) {
value = this._cast(value, _extends$2({
assert: false
}, options));
}
let args = {
value,
path,
options,
originalValue,
schema: this,
label: this.spec.label,
sync,
from
};
let initialTests = [];
if (this._typeError) initialTests.push(this._typeError);
if (this._whitelistError) initialTests.push(this._whitelistError);
if (this._blacklistError) initialTests.push(this._blacklistError);
runTests({
args,
value,
path,
sync,
tests: initialTests,
endEarly: abortEarly
}, (err) => {
if (err) return void cb(err, value);
runTests({
tests: this.tests,
args,
path,
sync,
value,
endEarly: abortEarly
}, cb);
});
}
validate(value, options, maybeCb) {
let schema = this.resolve(_extends$2({}, options, {
value
}));
return typeof maybeCb === "function" ? schema._validate(value, options, maybeCb) : new Promise((resolve, reject) => schema._validate(value, options, (err, value2) => {
if (err) reject(err);
else resolve(value2);
}));
}
validateSync(value, options) {
let schema = this.resolve(_extends$2({}, options, {
value
}));
let result;
schema._validate(value, _extends$2({}, options, {
sync: true
}), (err, value2) => {
if (err) throw err;
result = value2;
});
return result;
}
isValid(value, options) {
return this.validate(value, options).then(() => true, (err) => {
if (ValidationError.isError(err)) return false;
throw err;
});
}
isValidSync(value, options) {
try {
this.validateSync(value, options);
return true;
} catch (err) {
if (ValidationError.isError(err)) return false;
throw err;
}
}
_getDefault() {
let defaultValue = this.spec.default;
if (defaultValue == null) {
return defaultValue;
}
return typeof defaultValue === "function" ? defaultValue.call(this) : clone(defaultValue);
}
getDefault(options) {
let schema = this.resolve(options || {});
return schema._getDefault();
}
default(def) {
if (arguments.length === 0) {
return this._getDefault();
}
let next = this.clone({
default: def
});
return next;
}
strict(isStrict = true) {
var next = this.clone();
next.spec.strict = isStrict;
return next;
}
_isPresent(value) {
return value != null;
}
defined(message = mixed.defined) {
return this.test({
message,
name: "defined",
exclusive: true,
test(value) {
return value !== void 0;
}
});
}
required(message = mixed.required) {
return this.clone({
presence: "required"
}).withMutation((s) => s.test({
message,
name: "required",
exclusive: true,
test(value) {
return this.schema._isPresent(value);
}
}));
}
notRequired() {
var next = this.clone({
presence: "optional"
});
next.tests = next.tests.filter((test) => test.OPTIONS.name !== "required");
return next;
}
nullable(isNullable = true) {
var next = this.clone({
nullable: isNullable !== false
});
return next;
}
transform(fn) {
var next = this.clone();
next.transforms.push(fn);
return next;
}
/**
* Adds a test function to the schema's queue of tests.
* tests can be exclusive or non-exclusive.
*
* - exclusive tests, will replace any existing tests of the same name.
* - non-exclusive: can be stacked
*
* If a non-exclusive test is added to a schema with an exclusive test of the same name
* the exclusive test is removed and further tests of the same name will be stacked.
*
* If an exclusive test is added to a schema with non-exclusive tests of the same name
* the previous tests are removed and further tests of the same name will replace each other.
*/
test(...args) {
let opts;
if (args.length === 1) {
if (typeof args[0] === "function") {
opts = {
test: args[0]
};
} else {
opts = args[0];
}
} else if (args.length === 2) {
opts = {
name: args[0],
test: args[1]
};
} else {
opts = {
name: args[0],
message: args[1],
test: args[2]
};
}
if (opts.message === void 0) opts.message = mixed.default;
if (typeof opts.test !== "function") throw new TypeError("`test` is a required parameters");
let next = this.clone();
let validate = createValidation(opts);
let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
if (opts.exclusive) {
if (!opts.name) throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
}
if (opts.name) next.exclusiveTests[opts.name] = !!opts.exclusive;
next.tests = next.tests.filter((fn) => {
if (fn.OPTIONS.name === opts.name) {
if (isExclusive) return false;
if (fn.OPTIONS.test === validate.OPTIONS.test) return false;
}
return true;
});
next.tests.push(validate);
return next;
}
when(keys, options) {
if (!Array.isArray(keys) && typeof keys !== "string") {
options = keys;
keys = ".";
}
let next = this.clone();
let deps = toArray(keys).map((key) => new Reference(key));
deps.forEach((dep) => {
if (dep.isSibling) next.deps.push(dep.key);
});
next.conditions.push(new Condition(deps, options));
return next;
}
typeError(message) {
var next = this.clone();
next._typeError = createValidation({
message,
name: "typeError",
test(value) {
if (value !== void 0 && !this.schema.isType(value)) return this.createError({
params: {
type: this.schema._type
}
});
return true;
}
});
return next;
}
oneOf(enums, message = mixed.oneOf) {
var next = this.clone();
enums.forEach((val) => {
next._whitelist.add(val);
next._blacklist.delete(val);
});
next._whitelistError = createValidation({
message,
name: "oneOf",
test(value) {
if (value === void 0) return true;
let valids = this.schema._whitelist;
return valids.has(value, this.resolve) ? true : this.createError({
params: {
values: valids.toArray().join(", ")
}
});
}
});
return next;
}
notOneOf(enums, message = mixed.notOneOf) {
var next = this.clone();
enums.forEach((val) => {
next._blacklist.add(val);
next._whitelist.delete(val);
});
next._blacklistError = createValidation({
message,
name: "notOneOf",
test(value) {
let invalids = this.schema._blacklist;
if (invalids.has(value, this.resolve)) return this.createError({
params: {
values: invalids.toArray().join(", ")
}
});
return true;
}
});
return next;
}
strip(strip = true) {
let next = this.clone();
next.spec.strip = strip;
return next;
}
describe() {
const next = this.clone();
const {
label,
meta
} = next.spec;
const description2 = {
meta,
label,
type: next.type,
oneOf: next._whitelist.describe(),
notOneOf: next._blacklist.describe(),
tests: next.tests.map((fn) => ({
name: fn.OPTIONS.name,
params: fn.OPTIONS.params
})).filter((n, idx, list) => list.findIndex((c) => c.name === n.name) === idx)
};
return description2;
}
}
BaseSchema.prototype.__isYupSchema__ = true;
for (const method of ["validate", "validateSync"]) BaseSchema.prototype[`${method}At`] = function(path, value, options = {}) {
const {
parent,
parentPath,
schema
} = getIn(this, path, value, options.context);
return schema[method](parent && parent[parentPath], _extends$2({}, options, {
parent,
path
}));
};
for (const alias of ["equals", "is"]) BaseSchema.prototype[alias] = BaseSchema.prototype.oneOf;
for (const alias of ["not", "nope"]) BaseSchema.prototype[alias] = BaseSchema.prototype.notOneOf;
BaseSchema.prototype.optional = BaseSchema.prototype.notRequired;
const Mixed = BaseSchema;
Mixed.prototype;
const isAbsent = (value) => value == null;
let rEmail = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
let rUrl = /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
let rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
let isTrimmed = (value) => isAbsent(value) || value === value.trim();
let objStringTag = {}.toString();
function create$3() {
return new StringSchema();
}
class StringSchema extends BaseSchema {
constructor() {
super({
type: "string"
});
this.withMutation(() => {
this.transform(function(value) {
if (this.isType(value)) return value;
if (Array.isArray(value)) return value;
const strValue = value != null && value.toString ? value.toString() : value;
if (strValue === objStringTag) return value;
return strValue;
});
});
}
_typeCheck(value) {
if (value instanceof String) value = value.valueOf();
return typeof value === "string";
}
_isPresent(value) {
return super._isPresent(value) && !!value.length;
}
length(length, message = string.length) {
return this.test({
message,
name: "length",
exclusive: true,
params: {
length
},
test(value) {
return isAbsent(value) || value.length === this.resolve(length);
}
});
}
min(min, message = string.min) {
return this.test({
message,
name: "min",
exclusive: true,
params: {
min
},
test(value) {
return isAbsent(value) || value.length >= this.resolve(min);
}
});
}
max(max, message = string.max) {
return this.test({
name: "max",
exclusive: true,
message,
params: {
max
},
test(value) {
return isAbsent(value) || value.length <= this.resolve(max);
}
});
}
matches(regex, options) {
let excludeEmptyString = false;
let message;
let name2;
if (options) {
if (typeof options === "object") {
({
excludeEmptyString = false,
message,
name: name2
} = options);
} else {
message = options;
}
}
return this.test({
name: name2 || "matches",
message: message || string.matches,
params: {
regex
},
test: (value) => isAbsent(value) || value === "" && excludeEmptyString || value.search(regex) !== -1
});
}
email(message = string.email) {
return this.matches(rEmail, {
name: "email",
message,
excludeEmptyString: true
});
}
url(message = string.url) {
return this.matches(rUrl, {
name: "url",
message,
excludeEmptyString: true
});
}
uuid(message = string.uuid) {
return this.matches(rUUID, {
name: "uuid",
message,
excludeEmptyString: false
});
}
//-- transforms --
ensure() {
return this.default("").transform((val) => val === null ? "" : val);
}
trim(message = string.trim) {
return this.transform((val) => val != null ? val.trim() : val).test({
message,
name: "trim",
test: isTrimmed
});
}
lowercase(message = string.lowercase) {
return this.transform((value) => !isAbsent(value) ? value.toLowerCase() : value).test({
message,
name: "string_case",
exclusive: true,
test: (value) => isAbsent(value) || value === value.toLowerCase()
});
}
uppercase(message = string.uppercase) {
return this.transform((value) => !isAbsent(value) ? value.toUpperCase() : value).test({
message,
name: "string_case",
exclusive: true,
test: (value) => isAbsent(value) || value === value.toUpperCase()
});
}
}
create$3.prototype = StringSchema.prototype;
let isNaN$1 = (value) => value != +value;
function create$2() {
return new NumberSchema();
}
class NumberSchema extends BaseSchema {
constructor() {
super({
type: "number"
});
this.withMutation(() => {
this.transform(function(value) {
let parsed = value;
if (typeof parsed === "string") {
parsed = parsed.replace(/\s/g, "");
if (parsed === "") return NaN;
parsed = +parsed;
}
if (this.isType(parsed)) return parsed;
return parseFloat(parsed);
});
});
}
_typeCheck(value) {
if (value instanceof Number) value = value.valueOf();
return typeof value === "number" && !isNaN$1(value);
}
min(min, message = number.min) {
return this.test({
message,
name: "min",
exclusive: true,
params: {
min
},
test(value) {
return isAbsent(value) || value >= this.resolve(min);
}
});
}
max(max, message = number.max) {
return this.test({
message,
name: "max",
exclusive: true,
params: {
max
},
test(value) {
return isAbsent(value) || value <= this.resolve(max);
}
});
}
lessThan(less, message = number.lessThan) {
return this.test({
message,
name: "max",
exclusive: true,
params: {
less
},
test(value) {
return isAbsent(value) || value < this.resolve(less);
}
});
}
moreThan(more, message = number.moreThan) {
return this.test({
message,
name: "min",
exclusive: true,
params: {
more
},
test(value) {
return isAbsent(value) || value > this.resolve(more);
}
});
}
positive(msg = number.positive) {
return this.moreThan(0, msg);
}
negative(msg = number.negative) {
return this.lessThan(0, msg);
}
integer(message = number.integer) {
return this.test({
name: "integer",
message,
test: (val) => isAbsent(val) || Number.isInteger(val)
});
}
truncate() {
return this.transform((value) => !isAbsent(value) ? value | 0 : value);
}
round(method) {
var _method;
var avail = ["ceil", "floor", "round", "trunc"];
method = ((_method = method) == null ? void 0 : _method.toLowerCase()) || "round";
if (method === "trunc") return this.truncate();
if (avail.indexOf(method.toLowerCase()) === -1) throw new TypeError("Only valid options for round() are: " + avail.join(", "));
return this.transform((value) => !isAbsent(value) ? Math[method](value) : value);
}
}
create$2.prototype = NumberSchema.prototype;
var isoReg = /^(\d{4}|[+\-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,\.](\d{1,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?)?)?$/;
function parseIsoDate(date2) {
var numericKeys = [1, 4, 5, 6, 7, 10, 11], minutesOffset = 0, timestamp, struct;
if (struct = isoReg.exec(date2)) {
for (var i = 0, k; k = numericKeys[i]; ++i) struct[k] = +struct[k] || 0;
struct[2] = (+struct[2] || 1) - 1;
struct[3] = +struct[3] || 1;
struct[7] = struct[7] ? String(struct[7]).substr(0, 3) : 0;
if ((struct[8] === void 0 || struct[8] === "") && (struct[9] === void 0 || struct[9] === "")) timestamp = +new Date(struct[1], struct[2], struct[3], struct[4], struct[5], struct[6], struct[7]);
else {
if (struct[8] !== "Z" && struct[9] !== void 0) {
minutesOffset = struct[10] * 60 + struct[11];
if (struct[9] === "+") minutesOffset = 0 - minutesOffset;
}
timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]);
}
} else timestamp = Date.parse ? Date.parse(date2) : NaN;
return timestamp;
}
let invalidDate = /* @__PURE__ */ new Date("");
let isDate = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
class DateSchema extends BaseSchema {
constructor() {
super({
type: "date"
});
this.withMutation(() => {
this.transform(function(value) {
if (this.isType(value)) return value;
value = parseIsoDate(value);
return !isNaN(value) ? new Date(value) : invalidDate;
});
});
}
_typeCheck(v) {
return isDate(v) && !isNaN(v.getTime());
}
prepareParam(ref, name2) {
let param;
if (!Reference.isRef(ref)) {
let cast = this.cast(ref);
if (!this._typeCheck(cast)) throw new TypeError(`\`${name2}\` must be a Date or a value that can be \`cast()\` to a Date`);
param = cast;
} else {
param = ref;
}
return param;
}
min(min, message = date.min) {
let limit = this.prepareParam(min, "min");
return this.test({
message,
name: "min",
exclusive: true,
params: {
min
},
test(value) {
return isAbsent(value) || value >= this.resolve(limit);
}
});
}
max(max, message = date.max) {
var limit = this.prepareParam(max, "max");
return this.test({
message,
name: "max",
exclusive: true,
params: {
max
},
test(value) {
return isAbsent(value) || value <= this.resolve(limit);
}
});
}
}
DateSchema.INVALID_DATE = invalidDate;
DateSchema.prototype;
var toposort$2 = { exports: {} };
toposort$2.exports = function(edges) {
return toposort(uniqueNodes(edges), edges);
};
toposort$2.exports.array = toposort;
function toposort(nodes, edges) {
var cursor = nodes.length, sorted = new Array(cursor), visited = {}, i = cursor, outgoingEdges = makeOutgoingEdges(edges), nodesHash = makeNodesHash(nodes);
edges.forEach(function(edge) {
if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
throw new Error("Unknown node. There is an unknown node in the supplied edges.");
}
});
while (i--) {
if (!visited[i]) visit(nodes[i], i, /* @__PURE__ */ new Set());
}
return sorted;
function visit(node, i2, predecessors) {
if (predecessors.has(node)) {
var nodeRep;
try {
nodeRep = ", node was:" + JSON.stringify(node);
} catch (e) {
nodeRep = "";
}
throw new Error("Cyclic dependency" + nodeRep);
}
if (!nodesHash.has(node)) {
throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(node));
}
if (visited[i2]) return;
visited[i2] = true;
var outgoing = outgoingEdges.get(node) || /* @__PURE__ */ new Set();
outgoing = Array.from(outgoing);
if (i2 = outgoing.length) {
predecessors.add(node);
do {
var child = outgoing[--i2];
visit(child, nodesHash.get(child), predecessors);
} while (i2);
predecessors.delete(node);
}
sorted[--cursor] = node;
}
}
function uniqueNodes(arr) {
var res = /* @__PURE_