npm - @kklab/fortress-validator-plugin-json-schema - Versions diffs - 1.0.3 - Mend

@kklab/fortress-validator-plugin-json-schema 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/core/ajv.d.ts +4 -0
package/dist/index.d.ts +3 -0
package/dist/index.js +369 -0
package/dist/index.umd.js +1 -0
package/dist/locales/en.d.ts +3 -0
package/dist/locales/index.d.ts +3 -0
package/dist/locales/zh-TW.d.ts +3 -0
package/dist/localizers/en.d.ts +3 -0
package/dist/localizers/index.d.ts +3 -0
package/dist/localizers/zh-TW.d.ts +3 -0
package/dist/rules/index.d.ts +3 -0
package/dist/rules/jsonSchema.d.ts +8 -0
package/dist/rules/jsonSchema.test.d.ts +1 -0
package/dist/types/Localizer.d.ts +5 -0
package/dist/types/Localizers.d.ts +5 -0
package/package.json +55 -0

package/dist/core/ajv.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { default as Ajv, ValidateFunction } from 'ajv';
+declare const ajv: Ajv;
+declare const schemaCache: Map<string, ValidateFunction<unknown>>;
+export { ajv, schemaCache, };

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Plugin } from '@fortress-validator/types';
+declare const plugin: Plugin;
+export default plugin;

package/dist/index.js ADDED Viewed

@@ -0,0 +1,369 @@
+import p from "ajv";
+const l = {
+  jsonSchema: (r) => `The ${r} field must be a valid JSON Schema.`
+}, u = {
+  jsonSchema: () => "此欄位必須是有效的 JSON Schema"
+}, b = {
+  en: l,
+  "zh-TW": u
+}, $ = (r) => r == null || r === "" || Array.isArray(r) && r.length < 1, k = new p(), n = /* @__PURE__ */ new Map(), h = (r, t) => {
+  if (t)
+    for (const e of t) {
+      let a;
+      switch (e.keyword) {
+        case "additionalItems":
+        case "items": {
+          const s = e.params.limit;
+          a = `must NOT have more than ${s} item${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "additionalProperties": {
+          a = "must NOT have additional properties";
+          break;
+        }
+        case "anyOf": {
+          a = 'must match a schema in "anyOf"';
+          break;
+        }
+        case "const": {
+          a = "must be equal to constant";
+          break;
+        }
+        case "contains": {
+          a = "must contain a valid item";
+          break;
+        }
+        case "dependencies":
+        case "dependentRequired": {
+          a = `must have propert${e.params.depsCount == 1 ? "y" : "ies"} ${e.params.deps} when property ${e.params.property} is present`;
+          break;
+        }
+        case "discriminator": {
+          switch (e.params.error) {
+            case "tag": {
+              a = `tag "${e.params.tag}" must be string`;
+              break;
+            }
+            case "mapping": {
+              a = `value of tag "${e.params.tag}" must be in "oneOf"`;
+              break;
+            }
+            default:
+              a = `must pass "${e.keyword}" keyword validation`;
+          }
+          break;
+        }
+        case "enum": {
+          a = "must be equal to one of the allowed values";
+          break;
+        }
+        case "false schema": {
+          a = "boolean schema is false";
+          break;
+        }
+        case "format": {
+          a = `must match format "${e.params.format}"`;
+          break;
+        }
+        case "formatMaximum":
+        case "formatExclusiveMaximum": {
+          a = `must be ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "formatMinimum":
+        case "formatExclusiveMinimum": {
+          a = `must be ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "if": {
+          a = `must match "${e.params.failingKeyword}" schema`;
+          break;
+        }
+        case "maximum":
+        case "exclusiveMaximum": {
+          a = `must be ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "maxItems": {
+          const s = e.params.limit;
+          a = `must NOT have more than ${s} item${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "maxLength": {
+          const s = e.params.limit;
+          a = `must NOT be longer than ${s} character${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "maxProperties": {
+          const s = e.params.limit;
+          a = `must NOT have more than ${s} propert${s == 1 ? "y" : "ies"}`;
+          break;
+        }
+        case "minimum":
+        case "exclusiveMinimum": {
+          a = `must be ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "minItems": {
+          const s = e.params.limit;
+          a = `must NOT have less than ${s} item${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "minLength": {
+          const s = e.params.limit;
+          a = `must NOT be shorter than ${s} character${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "minProperties": {
+          const s = e.params.limit;
+          a = `must NOT have less than ${s} propert${s == 1 ? "y" : "ies"}`;
+          break;
+        }
+        case "multipleOf": {
+          a = `must be a multiple of ${e.params.multipleOf}`;
+          break;
+        }
+        case "not": {
+          a = 'must NOT be valid according to schema in "not"';
+          break;
+        }
+        case "oneOf": {
+          a = 'must match exactly one schema in "oneOf"';
+          break;
+        }
+        case "pattern": {
+          a = `must match pattern "${e.params.pattern}"`;
+          break;
+        }
+        case "patternRequired": {
+          a = `must have property matching pattern "${e.params.missingPattern}"`;
+          break;
+        }
+        case "propertyNames": {
+          a = "property name is invalid";
+          break;
+        }
+        case "required": {
+          a = `must have required property "${e.params.missingProperty}"`;
+          break;
+        }
+        case "type": {
+          a = `must be ${e.params.type}`;
+          break;
+        }
+        case "unevaluatedItems": {
+          const s = e.params.len;
+          a = `must NOT have more than ${s} item${s != 1 ? "s" : ""}`;
+          break;
+        }
+        case "unevaluatedProperties": {
+          a = "must NOT have unevaluated properties";
+          break;
+        }
+        case "uniqueItems": {
+          a = `must NOT have duplicate items (items #${e.params.j} and #${e.params.i} are identical)`;
+          break;
+        }
+        default:
+          a = `must pass "${e.keyword}" keyword validation`;
+      }
+      e.message = e.instancePath ? `The property at path "${e.instancePath}" ${a}.` : `The ${r.toLowerCase()} field ${a}.`;
+    }
+}, d = (r, t) => {
+  if (t)
+    for (const e of t) {
+      let a;
+      switch (e.keyword) {
+        case "additionalItems":
+        case "items": {
+          a = `不能超過 ${e.params.limit} 個元素`;
+          break;
+        }
+        case "additionalProperties": {
+          a = "不能有額外的屬性";
+          break;
+        }
+        case "anyOf": {
+          a = '必須符合 "anyOf" 指定的模式';
+          break;
+        }
+        case "const": {
+          a = "必須等於常數";
+          break;
+        }
+        case "contains": {
+          a = "必須包含一個有效元素";
+          break;
+        }
+        case "dependencies":
+        case "dependentRequired": {
+          a = `當 "${e.params.property}" 屬性存在時，必須有 "${e.params.deps}" 屬性`;
+          break;
+        }
+        case "discriminator": {
+          switch (e.params.error) {
+            case "tag": {
+              a = `標籤 "${e.params.tag}" 的類型必須是字串`;
+              break;
+            }
+            case "mapping": {
+              a = `標籤 "${e.params.tag}" 必須在 "oneOf" 其中之一`;
+              break;
+            }
+            default:
+              a = `必須通過 "${e.keyword}" 關鍵詞檢驗`;
+          }
+          break;
+        }
+        case "enum": {
+          a = "必須是指定的其中一個值";
+          break;
+        }
+        case "false schema": {
+          a = "布林模式不正確";
+          break;
+        }
+        case "format": {
+          a = `必須要符合 ${e.params.format} 格式`;
+          break;
+        }
+        case "formatMaximum":
+        case "formatExclusiveMaximum": {
+          a = `必須是 ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "formatMinimum":
+        case "formatExclusiveMinimum": {
+          a = `必須是 ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "if": {
+          a = `必須符合 "${e.params.failingKeyword}" 模式`;
+          break;
+        }
+        case "maximum":
+        case "exclusiveMaximum": {
+          a = `必須要 ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "maxItems": {
+          a = `不能多於 ${e.params.limit} 個`;
+          break;
+        }
+        case "maxLength": {
+          a = `不能多於 ${e.params.limit} 個字元`;
+          break;
+        }
+        case "maxProperties": {
+          a = `不能多於 ${e.params.limit} 個屬性`;
+          break;
+        }
+        case "minimum":
+        case "exclusiveMinimum": {
+          a = `必須要 ${e.params.comparison} ${e.params.limit}`;
+          break;
+        }
+        case "minItems": {
+          a = `不能少於 ${e.params.limit} 個`;
+          break;
+        }
+        case "minLength": {
+          a = `不能少於 ${e.params.limit} 個字元`;
+          break;
+        }
+        case "minProperties": {
+          a = `不能少於 ${e.params.limit} 個屬性`;
+          break;
+        }
+        case "multipleOf": {
+          a = `必須是 ${e.params.multipleOf} 的整數倍`;
+          break;
+        }
+        case "not": {
+          a = '必須不符合 "not" 中的模式';
+          break;
+        }
+        case "oneOf": {
+          a = '只能符合一個 "oneOf" 中的模式';
+          break;
+        }
+        case "pattern": {
+          a = `必須符合 "${e.params.pattern}" 模式`;
+          break;
+        }
+        case "patternRequired": {
+          a = `必須有符合 "${e.params.missingPattern}" 模式的屬性`;
+          break;
+        }
+        case "propertyNames": {
+          a = "必須是有效的属性名稱";
+          break;
+        }
+        case "required": {
+          a = `必須有 "${e.params.missingProperty}" 屬性`;
+          break;
+        }
+        case "type": {
+          a = `必須是 ${e.params.type} 類型`;
+          break;
+        }
+        case "unevaluatedItems": {
+          a = `不能超過 ${e.params.len} 個元素`;
+          break;
+        }
+        case "unevaluatedProperties": {
+          a = "不能有未驗證的屬性";
+          break;
+        }
+        case "uniqueItems": {
+          a = `不能有重複的元素（第 ${e.params.j} 項和第 ${e.params.i} 項是重複的）`;
+          break;
+        }
+        default:
+          a = `必須通過 "${e.keyword}" 關鍵詞檢驗`;
+      }
+      e.message = e.instancePath ? `路徑為 "${e.instancePath}" 的屬性${a}` : `此欄位${a}`;
+    }
+}, c = {
+  en: h,
+  "zh-TW": d
+}, f = ({ locale: r, field: t, schema: e }) => {
+  const a = y(e);
+  return (s) => {
+    if ($(s))
+      return !1;
+    if (typeof s == "string")
+      try {
+        s = JSON.parse(s);
+      } catch (i) {
+        return console.warn(i), !1;
+      }
+    if (a(s))
+      return !0;
+    const { errors: m } = a;
+    if (m && m.length > 0) {
+      (c[r] || c.en)(t, m);
+      const [o] = m;
+      return o.message || !1;
+    }
+    return !1;
+  };
+}, y = (r) => {
+  const t = JSON.stringify(r), e = n.get(t);
+  if (e)
+    return e;
+  try {
+    const a = k.compile(r);
+    return n.set(t, a), a;
+  } catch (a) {
+    throw new Error(`Invalid schema: ${a.message.replace("schema is invalid: ", "")}`);
+  }
+}, v = {
+  jsonSchema: f
+}, O = {
+  locales: b,
+  rules: v
+};
+export {
+  O as default
+};

package/dist/index.umd.js ADDED Viewed

@@ -0,0 +1 @@

package/dist/locales/en.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Messages } from '@fortress-validator/types';
+declare const en: Messages;
+export default en;

package/dist/locales/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Locales } from '@fortress-validator/types';
+declare const locales: Locales;
+export default locales;

package/dist/locales/zh-TW.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Messages } from '@fortress-validator/types';
+declare const en: Messages;
+export default en;

package/dist/localizers/en.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { default as Localizer } from '../types/Localizer';
+declare const localizer: Localizer;
+export default localizer;

package/dist/localizers/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { default as Localizers } from '../types/Localizers';
+declare const localizers: Localizers;
+export default localizers;

package/dist/localizers/zh-TW.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { default as Localizer } from '../types/Localizer';
+declare const localizer: Localizer;
+export default localizer;

package/dist/rules/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Rules } from '@fortress-validator/types';
+declare const rules: Rules;
+export default rules;

package/dist/rules/jsonSchema.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { Rule, RuleArguments } from '@fortress-validator/types';
+export interface JSONSchemaRuleArguments extends RuleArguments {
+    locale: string;
+    field: string;
+    schema: Record<string, unknown>;
+}
+declare const jsonSchema: Rule<JSONSchemaRuleArguments>;
+export default jsonSchema;

package/dist/rules/jsonSchema.test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/types/Localizer.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { ErrorObject } from 'ajv';
+interface Localizer {
+    (field: string, errors: ErrorObject[]): void;
+}
+export default Localizer;

package/dist/types/Localizers.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { default as Localizer } from './Localizer';
+interface Localizers {
+    [key: string]: Localizer;
+}
+export default Localizers;

package/package.json ADDED Viewed

@@ -0,0 +1,55 @@
+{
+  "name": "@kklab/fortress-validator-plugin-json-schema",
+  "private": false,
+  "version": "1.0.3",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -p ./tsconfig.build.json && vite build",
+    "preview": "vite preview",
+    "lint": "eslint lib",
+    "test": "npm run test:unit -- --run",
+    "test:unit": "vitest",
+    "release": "npm run test && npm run build && npm publish --access public"
+  },
+  "dependencies": {
+    "@fortress-validator/utils": "^1.0.0"
+  },
+  "peerDependencies": {
+    "ajv": "^8.17.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.7.0",
+    "@fortress-validator/types": "^1.0.0",
+    "@stylistic/eslint-plugin": "^2.9.0",
+    "@types/eslint__js": "^8.42.3",
+    "@types/node": "^20.14.12",
+    "eslint": "^8.57.0",
+    "globals": "^15.8.0",
+    "typescript": "^5.0.2",
+    "typescript-eslint": "^7.17.0",
+    "vite": "^4.4.5",
+    "vite-plugin-dts": "^4.2.3",
+    "vitest": "^2.1.2"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/kklab-com/vd/0-1-lab/chemi/fortress-validator-plugin-json-schema"
+  },
+  "keywords": [
+    "form",
+    "validation",
+    "validator"
+  ]
+}