1492 lines
50 KiB
JavaScript
1492 lines
50 KiB
JavaScript
"use strict";
|
|
exports["config.json"] = validate43;
|
|
const schema13 = {
|
|
"$id": "config.json",
|
|
"$schema": "http://json-schema.org/draft-07/schema#",
|
|
"type": "object",
|
|
"properties": {
|
|
"border": {
|
|
"$ref": "shared.json#/definitions/borders"
|
|
},
|
|
"columns": {
|
|
"$ref": "shared.json#/definitions/columns"
|
|
},
|
|
"columnDefault": {
|
|
"$ref": "shared.json#/definitions/column"
|
|
},
|
|
"drawHorizontalLine": {
|
|
"typeof": "function"
|
|
},
|
|
"singleLine": {
|
|
"typeof": "boolean"
|
|
}
|
|
},
|
|
"additionalProperties": false
|
|
};
|
|
const schema15 = {
|
|
"type": "object",
|
|
"properties": {
|
|
"topBody": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"topJoin": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"topLeft": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"topRight": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bottomBody": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bottomJoin": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bottomLeft": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bottomRight": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bodyLeft": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bodyRight": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"bodyJoin": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"joinBody": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"joinLeft": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"joinRight": {
|
|
"$ref": "#/definitions/border"
|
|
},
|
|
"joinJoin": {
|
|
"$ref": "#/definitions/border"
|
|
}
|
|
},
|
|
"additionalProperties": false
|
|
};
|
|
const schema16 = {
|
|
"type": "string"
|
|
};
|
|
|
|
function validate46(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (typeof data !== "string") {
|
|
const err0 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "string"
|
|
},
|
|
message: "should be string"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
validate46.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate45(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!(schema15.properties.hasOwnProperty(key0))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.topBody !== undefined) {
|
|
if (!(validate46(data.topBody, {
|
|
dataPath: dataPath + "/topBody",
|
|
parentData: data,
|
|
parentDataProperty: "topBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topJoin !== undefined) {
|
|
if (!(validate46(data.topJoin, {
|
|
dataPath: dataPath + "/topJoin",
|
|
parentData: data,
|
|
parentDataProperty: "topJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topLeft !== undefined) {
|
|
if (!(validate46(data.topLeft, {
|
|
dataPath: dataPath + "/topLeft",
|
|
parentData: data,
|
|
parentDataProperty: "topLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topRight !== undefined) {
|
|
if (!(validate46(data.topRight, {
|
|
dataPath: dataPath + "/topRight",
|
|
parentData: data,
|
|
parentDataProperty: "topRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomBody !== undefined) {
|
|
if (!(validate46(data.bottomBody, {
|
|
dataPath: dataPath + "/bottomBody",
|
|
parentData: data,
|
|
parentDataProperty: "bottomBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomJoin !== undefined) {
|
|
if (!(validate46(data.bottomJoin, {
|
|
dataPath: dataPath + "/bottomJoin",
|
|
parentData: data,
|
|
parentDataProperty: "bottomJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomLeft !== undefined) {
|
|
if (!(validate46(data.bottomLeft, {
|
|
dataPath: dataPath + "/bottomLeft",
|
|
parentData: data,
|
|
parentDataProperty: "bottomLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomRight !== undefined) {
|
|
if (!(validate46(data.bottomRight, {
|
|
dataPath: dataPath + "/bottomRight",
|
|
parentData: data,
|
|
parentDataProperty: "bottomRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyLeft !== undefined) {
|
|
if (!(validate46(data.bodyLeft, {
|
|
dataPath: dataPath + "/bodyLeft",
|
|
parentData: data,
|
|
parentDataProperty: "bodyLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyRight !== undefined) {
|
|
if (!(validate46(data.bodyRight, {
|
|
dataPath: dataPath + "/bodyRight",
|
|
parentData: data,
|
|
parentDataProperty: "bodyRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyJoin !== undefined) {
|
|
if (!(validate46(data.bodyJoin, {
|
|
dataPath: dataPath + "/bodyJoin",
|
|
parentData: data,
|
|
parentDataProperty: "bodyJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinBody !== undefined) {
|
|
if (!(validate46(data.joinBody, {
|
|
dataPath: dataPath + "/joinBody",
|
|
parentData: data,
|
|
parentDataProperty: "joinBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinLeft !== undefined) {
|
|
if (!(validate46(data.joinLeft, {
|
|
dataPath: dataPath + "/joinLeft",
|
|
parentData: data,
|
|
parentDataProperty: "joinLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinRight !== undefined) {
|
|
if (!(validate46(data.joinRight, {
|
|
dataPath: dataPath + "/joinRight",
|
|
parentData: data,
|
|
parentDataProperty: "joinRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinJoin !== undefined) {
|
|
if (!(validate46(data.joinJoin, {
|
|
dataPath: dataPath + "/joinJoin",
|
|
parentData: data,
|
|
parentDataProperty: "joinJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
} else {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
validate45.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
const schema17 = {
|
|
"type": "object",
|
|
"patternProperties": {
|
|
"^[0-9]+$": {
|
|
"$ref": "#/definitions/column"
|
|
}
|
|
},
|
|
"additionalProperties": false
|
|
};
|
|
const pattern0 = new RegExp("^[0-9]+$", "u");
|
|
const schema18 = {
|
|
"type": "object",
|
|
"properties": {
|
|
"alignment": {
|
|
"type": "string",
|
|
"enum": ["left", "right", "center"]
|
|
},
|
|
"width": {
|
|
"type": "number"
|
|
},
|
|
"wrapWord": {
|
|
"type": "boolean"
|
|
},
|
|
"truncate": {
|
|
"type": "number"
|
|
},
|
|
"paddingLeft": {
|
|
"type": "number"
|
|
},
|
|
"paddingRight": {
|
|
"type": "number"
|
|
}
|
|
},
|
|
"additionalProperties": false
|
|
};
|
|
const func0 = require("ajv/dist/compile/equal");
|
|
|
|
function validate64(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.alignment !== undefined) {
|
|
let data0 = data.alignment;
|
|
if (typeof data0 !== "string") {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/type",
|
|
params: {
|
|
type: "string"
|
|
},
|
|
message: "should be string"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
|
|
const err2 = {
|
|
keyword: "enum",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/enum",
|
|
params: {
|
|
allowedValues: schema18.properties.alignment.enum
|
|
},
|
|
message: "should be equal to one of the allowed values"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err2];
|
|
} else {
|
|
vErrors.push(err2);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.width !== undefined) {
|
|
let data1 = data.width;
|
|
if (!((typeof data1 == "number") && (isFinite(data1)))) {
|
|
const err3 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/width",
|
|
schemaPath: "#/properties/width/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err3];
|
|
} else {
|
|
vErrors.push(err3);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.wrapWord !== undefined) {
|
|
if (typeof data.wrapWord !== "boolean") {
|
|
const err4 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/wrapWord",
|
|
schemaPath: "#/properties/wrapWord/type",
|
|
params: {
|
|
type: "boolean"
|
|
},
|
|
message: "should be boolean"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err4];
|
|
} else {
|
|
vErrors.push(err4);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.truncate !== undefined) {
|
|
let data3 = data.truncate;
|
|
if (!((typeof data3 == "number") && (isFinite(data3)))) {
|
|
const err5 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/truncate",
|
|
schemaPath: "#/properties/truncate/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err5];
|
|
} else {
|
|
vErrors.push(err5);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingLeft !== undefined) {
|
|
let data4 = data.paddingLeft;
|
|
if (!((typeof data4 == "number") && (isFinite(data4)))) {
|
|
const err6 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingLeft",
|
|
schemaPath: "#/properties/paddingLeft/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err6];
|
|
} else {
|
|
vErrors.push(err6);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingRight !== undefined) {
|
|
let data5 = data.paddingRight;
|
|
if (!((typeof data5 == "number") && (isFinite(data5)))) {
|
|
const err7 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingRight",
|
|
schemaPath: "#/properties/paddingRight/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err7];
|
|
} else {
|
|
vErrors.push(err7);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
} else {
|
|
const err8 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err8];
|
|
} else {
|
|
vErrors.push(err8);
|
|
}
|
|
errors++;
|
|
}
|
|
validate64.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate63(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!(pattern0.test(key0))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
for (const key1 in data) {
|
|
if (pattern0.test(key1)) {
|
|
if (!(validate64(data[key1], {
|
|
dataPath: dataPath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
|
|
parentData: data,
|
|
parentDataProperty: key1,
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
validate63.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate67(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.alignment !== undefined) {
|
|
let data0 = data.alignment;
|
|
if (typeof data0 !== "string") {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/type",
|
|
params: {
|
|
type: "string"
|
|
},
|
|
message: "should be string"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
|
|
const err2 = {
|
|
keyword: "enum",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/enum",
|
|
params: {
|
|
allowedValues: schema18.properties.alignment.enum
|
|
},
|
|
message: "should be equal to one of the allowed values"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err2];
|
|
} else {
|
|
vErrors.push(err2);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.width !== undefined) {
|
|
let data1 = data.width;
|
|
if (!((typeof data1 == "number") && (isFinite(data1)))) {
|
|
const err3 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/width",
|
|
schemaPath: "#/properties/width/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err3];
|
|
} else {
|
|
vErrors.push(err3);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.wrapWord !== undefined) {
|
|
if (typeof data.wrapWord !== "boolean") {
|
|
const err4 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/wrapWord",
|
|
schemaPath: "#/properties/wrapWord/type",
|
|
params: {
|
|
type: "boolean"
|
|
},
|
|
message: "should be boolean"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err4];
|
|
} else {
|
|
vErrors.push(err4);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.truncate !== undefined) {
|
|
let data3 = data.truncate;
|
|
if (!((typeof data3 == "number") && (isFinite(data3)))) {
|
|
const err5 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/truncate",
|
|
schemaPath: "#/properties/truncate/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err5];
|
|
} else {
|
|
vErrors.push(err5);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingLeft !== undefined) {
|
|
let data4 = data.paddingLeft;
|
|
if (!((typeof data4 == "number") && (isFinite(data4)))) {
|
|
const err6 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingLeft",
|
|
schemaPath: "#/properties/paddingLeft/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err6];
|
|
} else {
|
|
vErrors.push(err6);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingRight !== undefined) {
|
|
let data5 = data.paddingRight;
|
|
if (!((typeof data5 == "number") && (isFinite(data5)))) {
|
|
const err7 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingRight",
|
|
schemaPath: "#/properties/paddingRight/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err7];
|
|
} else {
|
|
vErrors.push(err7);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
} else {
|
|
const err8 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err8];
|
|
} else {
|
|
vErrors.push(err8);
|
|
}
|
|
errors++;
|
|
}
|
|
validate67.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate43(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
/*# sourceURL="config.json" */ ;
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.border !== undefined) {
|
|
if (!(validate45(data.border, {
|
|
dataPath: dataPath + "/border",
|
|
parentData: data,
|
|
parentDataProperty: "border",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate45.errors : vErrors.concat(validate45.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.columns !== undefined) {
|
|
if (!(validate63(data.columns, {
|
|
dataPath: dataPath + "/columns",
|
|
parentData: data,
|
|
parentDataProperty: "columns",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate63.errors : vErrors.concat(validate63.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.columnDefault !== undefined) {
|
|
if (!(validate67(data.columnDefault, {
|
|
dataPath: dataPath + "/columnDefault",
|
|
parentData: data,
|
|
parentDataProperty: "columnDefault",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.drawHorizontalLine !== undefined) {
|
|
if (typeof data.drawHorizontalLine != "function") {
|
|
const err1 = {
|
|
keyword: "typeof",
|
|
dataPath: dataPath + "/drawHorizontalLine",
|
|
schemaPath: "#/properties/drawHorizontalLine/typeof",
|
|
params: {},
|
|
message: "should pass \"typeof\" keyword validation"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.singleLine !== undefined) {
|
|
if (typeof data.singleLine != "boolean") {
|
|
const err2 = {
|
|
keyword: "typeof",
|
|
dataPath: dataPath + "/singleLine",
|
|
schemaPath: "#/properties/singleLine/typeof",
|
|
params: {},
|
|
message: "should pass \"typeof\" keyword validation"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err2];
|
|
} else {
|
|
vErrors.push(err2);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
} else {
|
|
const err3 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err3];
|
|
} else {
|
|
vErrors.push(err3);
|
|
}
|
|
errors++;
|
|
}
|
|
validate43.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
exports["streamConfig.json"] = validate69;
|
|
const schema20 = {
|
|
"$id": "streamConfig.json",
|
|
"$schema": "http://json-schema.org/draft-07/schema#",
|
|
"type": "object",
|
|
"properties": {
|
|
"border": {
|
|
"$ref": "shared.json#/definitions/borders"
|
|
},
|
|
"columns": {
|
|
"$ref": "shared.json#/definitions/columns"
|
|
},
|
|
"columnDefault": {
|
|
"$ref": "shared.json#/definitions/column"
|
|
},
|
|
"columnCount": {
|
|
"type": "number"
|
|
}
|
|
},
|
|
"additionalProperties": false
|
|
};
|
|
|
|
function validate70(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!(schema15.properties.hasOwnProperty(key0))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.topBody !== undefined) {
|
|
if (!(validate46(data.topBody, {
|
|
dataPath: dataPath + "/topBody",
|
|
parentData: data,
|
|
parentDataProperty: "topBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topJoin !== undefined) {
|
|
if (!(validate46(data.topJoin, {
|
|
dataPath: dataPath + "/topJoin",
|
|
parentData: data,
|
|
parentDataProperty: "topJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topLeft !== undefined) {
|
|
if (!(validate46(data.topLeft, {
|
|
dataPath: dataPath + "/topLeft",
|
|
parentData: data,
|
|
parentDataProperty: "topLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.topRight !== undefined) {
|
|
if (!(validate46(data.topRight, {
|
|
dataPath: dataPath + "/topRight",
|
|
parentData: data,
|
|
parentDataProperty: "topRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomBody !== undefined) {
|
|
if (!(validate46(data.bottomBody, {
|
|
dataPath: dataPath + "/bottomBody",
|
|
parentData: data,
|
|
parentDataProperty: "bottomBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomJoin !== undefined) {
|
|
if (!(validate46(data.bottomJoin, {
|
|
dataPath: dataPath + "/bottomJoin",
|
|
parentData: data,
|
|
parentDataProperty: "bottomJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomLeft !== undefined) {
|
|
if (!(validate46(data.bottomLeft, {
|
|
dataPath: dataPath + "/bottomLeft",
|
|
parentData: data,
|
|
parentDataProperty: "bottomLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bottomRight !== undefined) {
|
|
if (!(validate46(data.bottomRight, {
|
|
dataPath: dataPath + "/bottomRight",
|
|
parentData: data,
|
|
parentDataProperty: "bottomRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyLeft !== undefined) {
|
|
if (!(validate46(data.bodyLeft, {
|
|
dataPath: dataPath + "/bodyLeft",
|
|
parentData: data,
|
|
parentDataProperty: "bodyLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyRight !== undefined) {
|
|
if (!(validate46(data.bodyRight, {
|
|
dataPath: dataPath + "/bodyRight",
|
|
parentData: data,
|
|
parentDataProperty: "bodyRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.bodyJoin !== undefined) {
|
|
if (!(validate46(data.bodyJoin, {
|
|
dataPath: dataPath + "/bodyJoin",
|
|
parentData: data,
|
|
parentDataProperty: "bodyJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinBody !== undefined) {
|
|
if (!(validate46(data.joinBody, {
|
|
dataPath: dataPath + "/joinBody",
|
|
parentData: data,
|
|
parentDataProperty: "joinBody",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinLeft !== undefined) {
|
|
if (!(validate46(data.joinLeft, {
|
|
dataPath: dataPath + "/joinLeft",
|
|
parentData: data,
|
|
parentDataProperty: "joinLeft",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinRight !== undefined) {
|
|
if (!(validate46(data.joinRight, {
|
|
dataPath: dataPath + "/joinRight",
|
|
parentData: data,
|
|
parentDataProperty: "joinRight",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.joinJoin !== undefined) {
|
|
if (!(validate46(data.joinJoin, {
|
|
dataPath: dataPath + "/joinJoin",
|
|
parentData: data,
|
|
parentDataProperty: "joinJoin",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
} else {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
validate70.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate87(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!(pattern0.test(key0))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
for (const key1 in data) {
|
|
if (pattern0.test(key1)) {
|
|
if (!(validate64(data[key1], {
|
|
dataPath: dataPath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
|
|
parentData: data,
|
|
parentDataProperty: key1,
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
validate87.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate90(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.alignment !== undefined) {
|
|
let data0 = data.alignment;
|
|
if (typeof data0 !== "string") {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/type",
|
|
params: {
|
|
type: "string"
|
|
},
|
|
message: "should be string"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
|
|
const err2 = {
|
|
keyword: "enum",
|
|
dataPath: dataPath + "/alignment",
|
|
schemaPath: "#/properties/alignment/enum",
|
|
params: {
|
|
allowedValues: schema18.properties.alignment.enum
|
|
},
|
|
message: "should be equal to one of the allowed values"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err2];
|
|
} else {
|
|
vErrors.push(err2);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.width !== undefined) {
|
|
let data1 = data.width;
|
|
if (!((typeof data1 == "number") && (isFinite(data1)))) {
|
|
const err3 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/width",
|
|
schemaPath: "#/properties/width/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err3];
|
|
} else {
|
|
vErrors.push(err3);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.wrapWord !== undefined) {
|
|
if (typeof data.wrapWord !== "boolean") {
|
|
const err4 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/wrapWord",
|
|
schemaPath: "#/properties/wrapWord/type",
|
|
params: {
|
|
type: "boolean"
|
|
},
|
|
message: "should be boolean"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err4];
|
|
} else {
|
|
vErrors.push(err4);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.truncate !== undefined) {
|
|
let data3 = data.truncate;
|
|
if (!((typeof data3 == "number") && (isFinite(data3)))) {
|
|
const err5 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/truncate",
|
|
schemaPath: "#/properties/truncate/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err5];
|
|
} else {
|
|
vErrors.push(err5);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingLeft !== undefined) {
|
|
let data4 = data.paddingLeft;
|
|
if (!((typeof data4 == "number") && (isFinite(data4)))) {
|
|
const err6 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingLeft",
|
|
schemaPath: "#/properties/paddingLeft/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err6];
|
|
} else {
|
|
vErrors.push(err6);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.paddingRight !== undefined) {
|
|
let data5 = data.paddingRight;
|
|
if (!((typeof data5 == "number") && (isFinite(data5)))) {
|
|
const err7 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/paddingRight",
|
|
schemaPath: "#/properties/paddingRight/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err7];
|
|
} else {
|
|
vErrors.push(err7);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
} else {
|
|
const err8 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err8];
|
|
} else {
|
|
vErrors.push(err8);
|
|
}
|
|
errors++;
|
|
}
|
|
validate90.errors = vErrors;
|
|
return errors === 0;
|
|
}
|
|
|
|
function validate69(data, {
|
|
dataPath = "",
|
|
parentData,
|
|
parentDataProperty,
|
|
rootData = data
|
|
} = {}) {
|
|
/*# sourceURL="streamConfig.json" */ ;
|
|
let vErrors = null;
|
|
let errors = 0;
|
|
if (data && typeof data == "object" && !Array.isArray(data)) {
|
|
for (const key0 in data) {
|
|
if (!((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount"))) {
|
|
const err0 = {
|
|
keyword: "additionalProperties",
|
|
dataPath,
|
|
schemaPath: "#/additionalProperties",
|
|
params: {
|
|
additionalProperty: key0
|
|
},
|
|
message: "should NOT have additional properties"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err0];
|
|
} else {
|
|
vErrors.push(err0);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
if (data.border !== undefined) {
|
|
if (!(validate70(data.border, {
|
|
dataPath: dataPath + "/border",
|
|
parentData: data,
|
|
parentDataProperty: "border",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate70.errors : vErrors.concat(validate70.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.columns !== undefined) {
|
|
if (!(validate87(data.columns, {
|
|
dataPath: dataPath + "/columns",
|
|
parentData: data,
|
|
parentDataProperty: "columns",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate87.errors : vErrors.concat(validate87.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.columnDefault !== undefined) {
|
|
if (!(validate90(data.columnDefault, {
|
|
dataPath: dataPath + "/columnDefault",
|
|
parentData: data,
|
|
parentDataProperty: "columnDefault",
|
|
rootData
|
|
}))) {
|
|
vErrors = vErrors === null ? validate90.errors : vErrors.concat(validate90.errors);
|
|
errors = vErrors.length;
|
|
}
|
|
}
|
|
if (data.columnCount !== undefined) {
|
|
let data3 = data.columnCount;
|
|
if (!((typeof data3 == "number") && (isFinite(data3)))) {
|
|
const err1 = {
|
|
keyword: "type",
|
|
dataPath: dataPath + "/columnCount",
|
|
schemaPath: "#/properties/columnCount/type",
|
|
params: {
|
|
type: "number"
|
|
},
|
|
message: "should be number"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err1];
|
|
} else {
|
|
vErrors.push(err1);
|
|
}
|
|
errors++;
|
|
}
|
|
}
|
|
} else {
|
|
const err2 = {
|
|
keyword: "type",
|
|
dataPath,
|
|
schemaPath: "#/type",
|
|
params: {
|
|
type: "object"
|
|
},
|
|
message: "should be object"
|
|
};
|
|
if (vErrors === null) {
|
|
vErrors = [err2];
|
|
} else {
|
|
vErrors.push(err2);
|
|
}
|
|
errors++;
|
|
}
|
|
validate69.errors = vErrors;
|
|
return errors === 0;
|
|
} |