https://www.eaglebrookchurch.com/Obsidian/ValidationRules.js

1System.register(['@Obsidian/Utility/booleanUtils', '@Obsidian/Utility/dateKey', '@Obsidian/Utility/email', '@Obsidian/Utility/numberUtils', '@Obsidian/Utility/stringUtils', '@Obsidian/Utility/url', '@Obsidian/Utility/validationRules', '@Obsidian/Utility/regexPatterns'], (function (exports) {
2    'use strict';
3    var asBooleanOrNull, DateKey, isEmail, toNumberOrNull, isNullOrWhiteSpace, containsHtmlTag, isUrl, defineRule, getSpecialCharacterPattern, getEmojiPattern, getSpecialFontPattern;
4    return {
5        setters: [function (module) {
6            asBooleanOrNull = module.asBooleanOrNull;
7        }, function (module) {
8            DateKey = module.default;
9        }, function (module) {
10            isEmail = module.isEmail;
11        }, function (module) {
12            toNumberOrNull = module.toNumberOrNull;
13        }, function (module) {
14            isNullOrWhiteSpace = module.isNullOrWhiteSpace;
15            containsHtmlTag = module.containsHtmlTag;
16        }, function (module) {
17            isUrl = module.isUrl;
18        }, function (module) {
19            defineRule = module.defineRule;
20            exports({ containsRequiredRule: module.containsRequiredRule, defineRule: module.defineRule, normalizeRules: module.normalizeRules, parseRule: module.parseRule, rulesPropType: module.rulesPropType, validateValue: module.validateValue });
21        }, function (module) {
22            getSpecialCharacterPattern = module.getSpecialCharacterPattern;
23            getEmojiPattern = module.getEmojiPattern;
24            getSpecialFontPattern = module.getSpecialFontPattern;
25        }],
26        execute: (function () {
27
28            function convertToNumber(value) {
29              if (typeof value === "number") {
30                return value;
31              }
32              if (typeof value === "string") {
33                return toNumberOrNull(value) || 0;
34              }
35              return 0;
36            }
37            function isNumeric(value) {
38              if (typeof value === "number") {
39                return true;
40              }
41              if (typeof value === "string") {
42                return toNumberOrNull(value) !== null;
43              }
44              return false;
45            }
46            defineRule("required", (value, params) => {
47              var options = params && params.length >= 1 && typeof params[0] === "string" ? JSON.parse(params[0]) : {};
48              if (typeof value === "string") {
49                var allowEmptyString = !!options.allowEmptyString;
50                if (!allowEmptyString && isNullOrWhiteSpace(value)) {
51                  return "is required";
52                }
53                return true;
54              }
55              if (typeof value === "number" && value === 0) {
56                return "is required";
57              }
58              if (Array.isArray(value) && value.length === 0) {
59                return "is required";
60              }
61              if (typeof value === "boolean") {
62                return true;
63              }
64              if (!value) {
65                return "is required";
66              }
67              return true;
68            });
69            defineRule("nospecialcharacters", value => {
70              if (typeof value === "string") {
71                if (getSpecialCharacterPattern().test(value)) {
72                  return "cannot contain special characters such as quotes, parentheses, etc.";
73                }
74              }
75              return true;
76            });
77            defineRule("noemojisorspecialfonts", value => {
78              if (typeof value === "string") {
79                if (getEmojiPattern().test(value) || getSpecialFontPattern().test(value)) {
80                  return "cannot contain emojis or special fonts.";
81                }
82              }
83              return true;
84            });
85            defineRule("notblank", value => {
86              if (value === undefined || value === null || value === "") {
87                return "cannot be blank";
88              }
89              return true;
90            });
91            defineRule("email", value => {
92              if (isNullOrWhiteSpace(value)) {
93                return true;
94              }
95              if (!isEmail(value)) {
96                return "must be a valid email";
97              }
98              return true;
99            });
100            defineRule("notequal", (value, params) => {
101              var compare = params && params.length >= 1 ? params[0] : undefined;
102              if (isNumeric(value) && isNumeric(compare)) {
103                if (convertToNumber(value) !== convertToNumber(compare)) {
104                  return true;
105                }
106              } else if (typeof value === "boolean") {
107                if (value !== asBooleanOrNull(compare)) {
108                  return true;
109                }
110              } else if (value !== compare) {
111                return true;
112              }
113              return "must not equal ".concat(compare);
114            });
115            defineRule("equal", (value, params) => {
116              var compare = params && params.length >= 1 ? params[0] : undefined;
117              if (isNumeric(value) && isNumeric(compare)) {
118                if (convertToNumber(value) === convertToNumber(compare)) {
119                  return true;
120                }
121              } else if (typeof value === "boolean") {
122                if (value === asBooleanOrNull(compare)) {
123                  return true;
124                }
125              } else if (value === compare) {
126                return true;
127              }
128              return "must equal ".concat(compare);
129            });
130            defineRule("gt", (value, params) => {
131              var compare = params && params.length >= 1 ? params[0] : undefined;
132              if (isNullOrWhiteSpace(value)) {
133                return true;
134              }
135              if (isNumeric(value) && isNumeric(compare)) {
136                if (convertToNumber(value) > convertToNumber(compare)) {
137                  return true;
138                }
139              }
140              return "must be greater than ".concat(compare);
141            });
142            defineRule("gte", (value, params) => {
143              var compare = params && params.length >= 1 ? params[0] : undefined;
144              if (isNullOrWhiteSpace(value)) {
145                return true;
146              }
147              if (isNumeric(value) && isNumeric(compare)) {
148                if (convertToNumber(value) >= convertToNumber(compare)) {
149                  return true;
150                }
151              }
152              return "must not be less than ".concat(compare);
153            });
154            defineRule("lt", (value, params) => {
155              var compare = params && params.length >= 1 ? params[0] : undefined;
156              if (isNullOrWhiteSpace(value)) {
157                return true;
158              }
159              if (isNumeric(value) && isNumeric(compare)) {
160                if (convertToNumber(value) < convertToNumber(compare)) {
161                  return true;
162                }
163              }
164              return "must be less than ".concat(compare);
165            });
166            defineRule("lte", (value, params) => {
167              var compare = params && params.length >= 1 ? params[0] : undefined;
168              if (isNullOrWhiteSpace(value)) {
169                return true;
170              }
171              if (isNumeric(value) && isNumeric(compare)) {
172                if (convertToNumber(value) <= convertToNumber(compare)) {
173                  return true;
174                }
175              }
176              return "must not be more than ".concat(compare);
177            });
178            defineRule("datekey", value => {
179              var asString = value;
180              if (!DateKey.getYear(asString)) {
181                return "must have a year";
182              }
183              if (!DateKey.getMonth(asString)) {
184                return "must have a month";
185              }
186              if (!DateKey.getDay(asString)) {
187                return "must have a day";
188              }
189              return true;
190            });
191            defineRule("number", value => {
192              if (isNullOrWhiteSpace(value)) {
193                return true;
194              }
195              if (isNumeric(value)) {
196                return true;
197              }
198              return "must be a valid number.";
199            });
200            defineRule("integer", value => {
201              if (isNullOrWhiteSpace(value)) {
202                return true;
203              }
204              if (/^-?[0-9]+$/.test(String(value))) {
205                return true;
206              }
207              return "must be an integer value.";
208            });
209            defineRule("decimal", value => {
210              if (isNullOrWhiteSpace(value)) {
211                return true;
212              }
213              if (/^-?[0-9]+(\.[0-9]+)?$/.test(String(value))) {
214                return true;
215              }
216              return "must be a decimal value.";
217            });
218            defineRule("ssn", value => {
219              if (isNullOrWhiteSpace(value)) {
220                return true;
221              }
222              if (/^[0-9]{3}-[0-9]{2}-[0-9]{4}$/.test(String(value))) {
223                return true;
224              }
225              if (/^[0-9]{9}$/.test(String(value))) {
226                return true;
227              }
228              return "must be a valid social security number";
229            });
230            defineRule("url", value => {
231              if (isNullOrWhiteSpace(value)) {
232                return true;
233              }
234              if (isUrl(String(value))) {
235                return true;
236              }
237              return "must be a valid URL";
238            });
239            defineRule("endswith", (value, params) => {
240              var compare = params && params.length >= 1 ? params[0] : undefined;
241              if (isNullOrWhiteSpace(value)) {
242                return true;
243              }
244              if (!String(compare)) {
245                return true;
246              }
247              if (String(value).endsWith(String(compare))) {
248                return true;
249              }
250              return "must end with \"".concat(compare, "\"");
251            });
252            defineRule("startswith", (value, params) => {
253              var compare = params && params.length >= 1 ? params[0] : undefined;
254              if (isNullOrWhiteSpace(value)) {
255                return true;
256              }
257              if (!String(compare)) {
258                return true;
259              }
260              if (String(value).startsWith(String(compare))) {
261                return true;
262              }
263              return "must start with \"".concat(compare, "\"");
264            });
265            defineRule("equalsfield", (value, params) => {
266              var error = params && params.length >= 1 ? params[0] : undefined;
267              var compare = params ? params.slice(1).join(",") : "";
268              if (isNumeric(value) && isNumeric(compare)) {
269                if (convertToNumber(value) === convertToNumber(compare)) {
270                  return true;
271                }
272              } else if (typeof value === "boolean") {
273                if (value === asBooleanOrNull(compare)) {
274                  return true;
275                }
276              } else if (value === compare) {
277                return true;
278              }
279              return typeof error === "string" ? error : "must match value";
280            });
281            defineRule("nohtml", value => {
282              if (isNullOrWhiteSpace(value)) {
283                return true;
284              }
285              return !containsHtmlTag(String(value)) || "contains invali

285d characters. Please make sure that your entries do not contain any angle brackets like < or >.";
286            });
287
288        })
289    };
290}));
291//# sourceMappingURL=ValidationRules.js.map