New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
schemastery
Advanced tools
schemastery - npm Package Compare versions
Comparing version 3.1.1 to 3.2.0
@@ -1,357 +0,1 @@ | ||
| var __defProp = Object.defineProperty; | ||
| var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); | ||
| // community/schemastery/src/index.ts | ||
| function isNullable(value) { | ||
| return value === null || value === void 0; | ||
| } | ||
| __name(isNullable, "isNullable"); | ||
| function isPlainObject(data) { | ||
| return data && typeof data === "object" && !Array.isArray(data); | ||
| } | ||
| __name(isPlainObject, "isPlainObject"); | ||
| function valueMap(object, transform) { | ||
| return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)])); | ||
| } | ||
| __name(valueMap, "valueMap"); | ||
| function clone(source) { | ||
| if (!source || typeof source !== "object") | ||
| return source; | ||
| if (Array.isArray(source)) | ||
| return source.map(clone); | ||
| if (source instanceof Date) | ||
| return new Date(source.valueOf()); | ||
| if (source instanceof RegExp) | ||
| return new RegExp(source.source, source.flags); | ||
| return valueMap(source, clone); | ||
| } | ||
| __name(clone, "clone"); | ||
| var index = 0; | ||
| var kSchema = Symbol("schemastery"); | ||
| var Schema = /* @__PURE__ */ __name(function(options) { | ||
| const schema = /* @__PURE__ */ __name(function(data) { | ||
| return Schema.resolve(data, schema)[0]; | ||
| }, "schema"); | ||
| if (options.refs) { | ||
| const refs2 = valueMap(options.refs, (options2) => new Schema(options2)); | ||
| const getRef = /* @__PURE__ */ __name((uid) => refs2[uid], "getRef"); | ||
| for (const key in refs2) { | ||
| const options2 = refs2[key]; | ||
| options2.sKey = getRef(options2.sKey); | ||
| options2.inner = getRef(options2.inner); | ||
| options2.list = options2.list && options2.list.map(getRef); | ||
| options2.dict = options2.dict && valueMap(options2.dict, getRef); | ||
| } | ||
| return refs2[options.uid]; | ||
| } | ||
| Object.assign(schema, options); | ||
| Object.defineProperty(schema, "uid", { value: index++ }); | ||
| Object.setPrototypeOf(schema, Schema.prototype); | ||
| schema.meta ||= {}; | ||
| return schema; | ||
| }, "Schema"); | ||
| Schema.prototype = Object.create(Function.prototype); | ||
| Schema.prototype[kSchema] = true; | ||
| var refs; | ||
| Schema.prototype.toJSON = /* @__PURE__ */ __name(function toJSON() { | ||
| if (refs) { | ||
| refs[this.uid] ??= JSON.parse(JSON.stringify({ ...this })); | ||
| return this.uid; | ||
| } | ||
| refs = { [this.uid]: { ...this } }; | ||
| refs[this.uid] = JSON.parse(JSON.stringify({ ...this })); | ||
| const result = { uid: this.uid, refs }; | ||
| refs = null; | ||
| return result; | ||
| }, "toJSON"); | ||
| Schema.prototype.set = /* @__PURE__ */ __name(function set(key, value) { | ||
| this.dict[key] = value; | ||
| return this; | ||
| }, "set"); | ||
| Schema.prototype.push = /* @__PURE__ */ __name(function push(value) { | ||
| this.list.push(value); | ||
| return this; | ||
| }, "push"); | ||
| for (const key of ["required", "hidden"]) { | ||
| Object.assign(Schema.prototype, { | ||
| [key](value = true) { | ||
| const schema = Schema(this); | ||
| schema.meta = { ...schema.meta, [key]: value }; | ||
| return schema; | ||
| } | ||
| }); | ||
| } | ||
| for (const key of ["default", "role", "link", "comment", "description", "max", "min", "step"]) { | ||
| Object.assign(Schema.prototype, { | ||
| [key](value) { | ||
| const schema = Schema(this); | ||
| schema.meta = { ...schema.meta, [key]: value }; | ||
| return schema; | ||
| } | ||
| }); | ||
| } | ||
| var resolvers = {}; | ||
| Schema.extend = /* @__PURE__ */ __name(function extend(type, resolve2) { | ||
| resolvers[type] = resolve2; | ||
| }, "extend"); | ||
| Schema.resolve = /* @__PURE__ */ __name(function resolve(data, schema, strict) { | ||
| if (!schema) | ||
| return [data]; | ||
| if (isNullable(data)) { | ||
| if (schema.meta.required) | ||
| throw new TypeError(`missing required value`); | ||
| const fallback = schema.meta.default; | ||
| if (isNullable(fallback)) | ||
| return [data]; | ||
| data = clone(fallback); | ||
| } | ||
| const callback = resolvers[schema.type]; | ||
| if (callback) | ||
| return callback(data, schema, strict); | ||
| throw new TypeError(`unsupported type "${schema.type}"`); | ||
| }, "resolve"); | ||
| Schema.from = /* @__PURE__ */ __name(function from(source) { | ||
| if (isNullable(source)) { | ||
| return Schema.any(); | ||
| } else if (["string", "number", "boolean"].includes(typeof source)) { | ||
| return Schema.const(source).required(); | ||
| } else if (source[kSchema]) { | ||
| return source; | ||
| } else if (typeof source === "function") { | ||
| switch (source) { | ||
| case String: | ||
| return Schema.string().required(); | ||
| case Number: | ||
| return Schema.number().required(); | ||
| case Boolean: | ||
| return Schema.boolean().required(); | ||
| case Function: | ||
| return Schema.function().required(); | ||
| default: | ||
| return Schema.is(source).required(); | ||
| } | ||
| } else { | ||
| throw new TypeError(`cannot infer schema from ${source}`); | ||
| } | ||
| }, "from"); | ||
| Schema.natural = /* @__PURE__ */ __name(function natural() { | ||
| return Schema.number().step(1).min(0); | ||
| }, "natural"); | ||
| Schema.percent = /* @__PURE__ */ __name(function percent() { | ||
| return Schema.number().step(0.01).min(0).max(1).role("slider"); | ||
| }, "percent"); | ||
| Schema.extend("any", (data) => { | ||
| return [data]; | ||
| }); | ||
| Schema.extend("never", (data) => { | ||
| throw new TypeError(`expected nullable but got ${data}`); | ||
| }); | ||
| Schema.extend("const", (data, { value }) => { | ||
| if (data === value) | ||
| return [value]; | ||
| throw new TypeError(`expected ${value} but got ${data}`); | ||
| }); | ||
| Schema.extend("string", (data) => { | ||
| if (typeof data === "string") | ||
| return [data]; | ||
| throw new TypeError(`expected string but got ${data}`); | ||
| }); | ||
| Schema.extend("number", (data, { meta }) => { | ||
| const { max = Infinity, min = -Infinity, step } = meta; | ||
| if (typeof data !== "number") | ||
| throw new TypeError(`expected number but got ${data}`); | ||
| if (data > max) | ||
| throw new TypeError(`expected number <= ${max} but got ${data}`); | ||
| if (data < min) | ||
| throw new TypeError(`expected number >= ${min} but got ${data}`); | ||
| if (step) { | ||
| const quotient = Math.abs(data - (meta.min ?? 0)) % step; | ||
| if (quotient >= Number.EPSILON && quotient < step - Number.EPSILON) { | ||
| throw new TypeError(`expected number multiple of ${step} but got ${data}`); | ||
| } | ||
| } | ||
| return [data]; | ||
| }); | ||
| Schema.extend("boolean", (data) => { | ||
| if (typeof data === "boolean") | ||
| return [data]; | ||
| throw new TypeError(`expected boolean but got ${data}`); | ||
| }); | ||
| Schema.extend("function", (data) => { | ||
| if (typeof data === "function") | ||
| return [data]; | ||
| throw new TypeError(`expected function but got ${data}`); | ||
| }); | ||
| Schema.extend("is", (data, { callback }) => { | ||
| if (data instanceof callback) | ||
| return [data]; | ||
| throw new TypeError(`expected ${callback.name} but got ${data}`); | ||
| }); | ||
| function property(data, key, schema) { | ||
| const [value, adapted] = Schema.resolve(data[key], schema); | ||
| if (!isNullable(adapted)) | ||
| data[key] = adapted; | ||
| return value; | ||
| } | ||
| __name(property, "property"); | ||
| Schema.extend("array", (data, { inner }) => { | ||
| if (!Array.isArray(data)) | ||
| throw new TypeError(`expected array but got ${data}`); | ||
| return [data.map((_, index2) => property(data, index2, inner))]; | ||
| }); | ||
| Schema.extend("dict", (data, { inner, sKey }, strict) => { | ||
| if (!isPlainObject(data)) | ||
| throw new TypeError(`expected object but got ${data}`); | ||
| const result = {}; | ||
| for (const key in data) { | ||
| let rKey; | ||
| try { | ||
| rKey = Schema.resolve(key, sKey)[0]; | ||
| } catch (error) { | ||
| if (strict) | ||
| continue; | ||
| throw error; | ||
| } | ||
| result[rKey] = property(data, key, inner); | ||
| data[rKey] = data[key]; | ||
| if (key !== rKey) | ||
| delete data[key]; | ||
| } | ||
| return [result]; | ||
| }); | ||
| Schema.extend("tuple", (data, { list }, strict) => { | ||
| if (!Array.isArray(data)) | ||
| throw new TypeError(`expected array but got ${data}`); | ||
| const result = list.map((inner, index2) => property(data, index2, inner)); | ||
| if (strict) | ||
| return [result]; | ||
| result.push(...data.slice(list.length)); | ||
| return [result]; | ||
| }); | ||
| function merge(result, data) { | ||
| for (const key in data) { | ||
| if (key in result) | ||
| continue; | ||
| result[key] = data[key]; | ||
| } | ||
| } | ||
| __name(merge, "merge"); | ||
| Schema.extend("object", (data, { dict }, strict) => { | ||
| if (!isPlainObject(data)) | ||
| throw new TypeError(`expected object but got ${data}`); | ||
| const result = {}; | ||
| for (const key in dict) { | ||
| const value = property(data, key, dict[key]); | ||
| if (!isNullable(value) || key in data) { | ||
| result[key] = value; | ||
| } | ||
| } | ||
| if (!strict) | ||
| merge(result, data); | ||
| return [result]; | ||
| }); | ||
| Schema.extend("union", (data, { list, toString }) => { | ||
| const messages = []; | ||
| for (const inner of list) { | ||
| try { | ||
| return Schema.resolve(data, inner); | ||
| } catch (error) { | ||
| messages.push(error.message); | ||
| } | ||
| } | ||
| throw new TypeError(`expected ${toString()} but got ${JSON.stringify(data)}`); | ||
| }); | ||
| Schema.extend("intersect", (data, { list }, strict) => { | ||
| const result = {}; | ||
| for (const inner of list) { | ||
| const value = Schema.resolve(data, inner, true)[0]; | ||
| Object.assign(result, value); | ||
| } | ||
| if (!strict && isPlainObject(data)) | ||
| merge(result, data); | ||
| return [result]; | ||
| }); | ||
| Schema.extend("transform", (data, { inner, callback }) => { | ||
| const [result, adapted = data] = Schema.resolve(data, inner, true); | ||
| if (isPlainObject(data)) { | ||
| const temp = {}; | ||
| for (const key in result) { | ||
| if (!(key in data)) | ||
| continue; | ||
| temp[key] = data[key]; | ||
| delete data[key]; | ||
| } | ||
| Object.assign(data, callback(temp)); | ||
| return [callback(result)]; | ||
| } else { | ||
| return [callback(result), callback(adapted)]; | ||
| } | ||
| }); | ||
| function defineMethod(name, keys, format) { | ||
| Object.assign(Schema, { | ||
| [name](...args) { | ||
| const schema = new Schema({ type: name }); | ||
| schema.toString = format.bind(null, schema); | ||
| keys.forEach((key, index2) => { | ||
| switch (key) { | ||
| case "sKey": | ||
| schema.sKey = args[index2] ?? Schema.string(); | ||
| break; | ||
| case "inner": | ||
| schema.inner = Schema.from(args[index2]); | ||
| break; | ||
| case "list": | ||
| schema.list = args[index2].map(Schema.from); | ||
| break; | ||
| case "dict": | ||
| schema.dict = valueMap(args[index2], Schema.from); | ||
| break; | ||
| default: | ||
| schema[key] = args[index2]; | ||
| } | ||
| }); | ||
| if (name === "object" || name === "dict") { | ||
| schema.meta.default = {}; | ||
| } else if (name === "array" || name === "tuple") { | ||
| schema.meta.default = []; | ||
| } | ||
| return schema; | ||
| } | ||
| }); | ||
| } | ||
| __name(defineMethod, "defineMethod"); | ||
| defineMethod("is", ["callback"], ({ callback }) => callback.name); | ||
| defineMethod("any", [], () => "any"); | ||
| defineMethod("never", [], () => "never"); | ||
| defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value); | ||
| defineMethod("string", [], () => "string"); | ||
| defineMethod("number", [], () => "number"); | ||
| defineMethod("boolean", [], () => "boolean"); | ||
| defineMethod("function", [], () => "function"); | ||
| defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`); | ||
| defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`); | ||
| defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`); | ||
| defineMethod("object", ["dict"], ({ dict }) => { | ||
| if (Object.keys(dict).length === 0) | ||
| return "{}"; | ||
| return `{ ${Object.entries(dict).map(([key, inner]) => { | ||
| return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`; | ||
| }).join(", ")} }`; | ||
| }); | ||
| defineMethod("union", ["list"], ({ list }, inline) => { | ||
| const result = list.map(({ toString: format }) => format()).join(" | "); | ||
| return inline ? `(${result})` : result; | ||
| }); | ||
| defineMethod("intersect", ["list"], ({ list }) => { | ||
| return `${list.map((inner) => inner.toString(true)).join(" & ")}`; | ||
| }); | ||
| defineMethod("transform", ["inner", "callback"], ({ inner }, isInner) => inner.toString(isInner)); | ||
| var src_default = Schema; | ||
| export { | ||
| clone, | ||
| src_default as default, | ||
| isNullable, | ||
| isPlainObject, | ||
| valueMap | ||
| }; | ||
| //# sourceMappingURL=browser.js.map | ||
| var x=Object.defineProperty;var s=(e,t)=>x(e,"name",{value:t,configurable:!0});function p(e){return e==null}s(p,"isNullable");function m(e){return e&&typeof e=="object"&&!Array.isArray(e)}s(m,"isPlainObject");function f(e,t){return Object.fromEntries(Object.entries(e).map(([n,o])=>[n,t(o,n)]))}s(f,"valueMap");function S(e){return!e||typeof e!="object"?e:Array.isArray(e)?e.map(S):e instanceof Date?new Date(e.valueOf()):e instanceof RegExp?new RegExp(e.source,e.flags):f(e,S)}s(S,"clone");var w=0,T=Symbol("schemastery"),r=s(function(e){let t=s(function(n){return r.resolve(n,t)[0]},"schema");if(e.refs){let n=f(e.refs,i=>new r(i)),o=s(i=>n[i],"getRef");for(let i in n){let c=n[i];c.sKey=o(c.sKey),c.inner=o(c.inner),c.list=c.list&&c.list.map(o),c.dict=c.dict&&f(c.dict,o)}return n[e.uid]}return Object.assign(t,e),Object.defineProperty(t,"uid",{value:w++}),Object.setPrototypeOf(t,r.prototype),t.meta||={},t},"Schema");r.prototype=Object.create(Function.prototype);r.prototype[T]=!0;var y;r.prototype.toJSON=s(function(){if(y)return y[this.uid]??=JSON.parse(JSON.stringify({...this})),this.uid;y={[this.uid]:{...this}},y[this.uid]=JSON.parse(JSON.stringify({...this}));let t={uid:this.uid,refs:y};return y=null,t},"toJSON");r.prototype.set=s(function(t,n){return this.dict[t]=n,this},"set");r.prototype.push=s(function(t){return this.list.push(t),this},"push");for(let e of["required","hidden"])Object.assign(r.prototype,{[e](t=!0){let n=r(this);return n.meta={...n.meta,[e]:t},n}});for(let e of["default","role","link","comment","description","max","min","step"])Object.assign(r.prototype,{[e](t){let n=r(this);return n.meta={...n.meta,[e]:t},n}});var b={};r.extend=s(function(t,n){b[t]=n},"extend");r.resolve=s(function(t,n,o){if(!n)return[t];if(p(t)){if(n.meta.required)throw new TypeError("missing required value");let c=n.meta.default;if(p(c))return[t];t=S(c)}let i=b[n.type];if(i)return i(t,n,o);throw new TypeError(`unsupported type "${n.type}"`)},"resolve");r.from=s(function(t){if(p(t))return r.any();if(["string","number","boolean"].includes(typeof t))return r.const(t).required();if(t[T])return t;if(typeof t=="function")switch(t){case String:return r.string().required();case Number:return r.number().required();case Boolean:return r.boolean().required();case Function:return r.function().required();default:return r.is(t).required()}else throw new TypeError(`cannot infer schema from ${t}`)},"from");r.natural=s(function(){return r.number().step(1).min(0)},"natural");r.percent=s(function(){return r.number().step(.01).min(0).max(1).role("slider")},"percent");r.extend("any",e=>[e]);r.extend("never",e=>{throw new TypeError(`expected nullable but got ${e}`)});r.extend("const",(e,{value:t})=>{if(e===t)return[t];throw new TypeError(`expected ${t} but got ${e}`)});function h(e,t,n){let{max:o=1/0,min:i=-1/0}=t;if(e>o)throw new TypeError(`expected ${n} <= ${o} but got ${e}`);if(e<i)throw new TypeError(`expected ${n} >= ${i} but got ${e}`)}s(h,"checkWithinRange");r.extend("string",(e,{meta:t})=>{if(typeof e!="string")throw new TypeError(`expected string but got ${e}`);return h(e.length,t,"string length"),[e]});r.extend("number",(e,{meta:t})=>{if(typeof e!="number")throw new TypeError(`expected number but got ${e}`);h(e,t,"number");let{step:n}=t;if(n){let o=Math.abs(e-(t.min??0))%n;if(o>=Number.EPSILON&&o<n-Number.EPSILON)throw new TypeError(`expected number multiple of ${n} but got ${e}`)}return[e]});r.extend("boolean",e=>{if(typeof e=="boolean")return[e];throw new TypeError(`expected boolean but got ${e}`)});r.extend("function",e=>{if(typeof e=="function")return[e];throw new TypeError(`expected function but got ${e}`)});r.extend("is",(e,{callback:t})=>{if(e instanceof t)return[e];throw new TypeError(`expected ${t.name} but got ${e}`)});function l(e,t,n){let[o,i]=r.resolve(e[t],n);return p(i)||(e[t]=i),o}s(l,"property");r.extend("array",(e,{inner:t,meta:n})=>{if(!Array.isArray(e))throw new TypeError(`expected array but got ${e}`);return h(e.length,n,"array length"),[e.map((o,i)=>l(e,i,t))]});r.extend("dict",(e,{inner:t,sKey:n},o)=>{if(!m(e))throw new TypeError(`expected object but got ${e}`);let i={};for(let c in e){let u;try{u=r.resolve(c,n)[0]}catch(d){if(o)continue;throw d}i[u]=l(e,c,t),e[u]=e[c],c!==u&&delete e[c]}return[i]});r.extend("tuple",(e,{list:t},n)=>{if(!Array.isArray(e))throw new TypeError(`expected array but got ${e}`);let o=t.map((i,c)=>l(e,c,i));return n?[o]:(o.push(...e.slice(t.length)),[o])});function g(e,t){for(let n in t)n in e||(e[n]=t[n])}s(g,"merge");r.extend("object",(e,{dict:t},n)=>{if(!m(e))throw new TypeError(`expected object but got ${e}`);let o={};for(let i in t){let c=l(e,i,t[i]);(!p(c)||i in e)&&(o[i]=c)}return n||g(o,e),[o]});r.extend("union",(e,{list:t,toString:n})=>{let o=[];for(let i of t)try{return r.resolve(e,i)}catch(c){o.push(c.message)}throw new TypeError(`expected ${n()} but got ${JSON.stringify(e)}`)});r.extend("intersect",(e,{list:t},n)=>{let o={};for(let i of t){let c=r.resolve(e,i,!0)[0];Object.assign(o,c)}return!n&&m(e)&&g(o,e),[o]});r.extend("transform",(e,{inner:t,callback:n})=>{let[o,i=e]=r.resolve(e,t,!0);if(m(e)){let c={};for(let u in o)u in e&&(c[u]=e[u],delete e[u]);return Object.assign(e,n(c)),[n(o)]}else return[n(o),n(i)]});function a(e,t,n){Object.assign(r,{[e](...o){let i=new r({type:e});return i.toString=n.bind(null,i),t.forEach((c,u)=>{switch(c){case"sKey":i.sKey=o[u]??r.string();break;case"inner":i.inner=r.from(o[u]);break;case"list":i.list=o[u].map(r.from);break;case"dict":i.dict=f(o[u],r.from);break;default:i[c]=o[u]}}),e==="object"||e==="dict"?i.meta.default={}:(e==="array"||e==="tuple")&&(i.meta.default=[]),i}})}s(a,"defineMethod");a("is",["callback"],({callback:e})=>e.name);a("any",[],()=>"any");a("never",[],()=>"never");a("const",["value"],({value:e})=>typeof e=="string"?JSON.stringify(e):e);a("string",[],()=>"string");a("number",[],()=>"number");a("boolean",[],()=>"boolean");a("function",[],()=>"function");a("array",["inner"],({inner:e})=>`${e.toString(!0)}[]`);a("dict",["inner","sKey"],({inner:e,sKey:t})=>`{ [key: ${t.toString()}]: ${e.toString()} }`);a("tuple",["list"],({list:e})=>`[${e.map(t=>t.toString()).join(", ")}]`);a("object",["dict"],({dict:e})=>Object.keys(e).length===0?"{}":`{ ${Object.entries(e).map(([t,n])=>`${t}${n.meta.required?"":"?"}: ${n.toString()}`).join(", ")} }`);a("union",["list"],({list:e},t)=>{let n=e.map(({toString:o})=>o()).join(" | ");return t?`(${n})`:n});a("intersect",["list"],({list:e})=>`${e.map(t=>t.toString(!0)).join(" & ")}`);a("transform",["inner","callback"],({inner:e},t)=>e.toString(t));var v=r;export{S as clone,v as default,p as isNullable,m as isPlainObject,f as valueMap}; |
@@ -75,3 +75,3 @@ export declare type Dict<T = any, K extends string = string> = { | ||
| resolve: Resolve; | ||
| from<T>(source: T): Schema<From<T>>; | ||
| from<T = any>(source?: T): Schema<From<T>>; | ||
| extend(type: string, resolve: Resolve): void; | ||
@@ -78,0 +78,0 @@ any(): Schema<any>; |
@@ -186,16 +186,22 @@ var __defProp = Object.defineProperty; | ||
| }); | ||
| Schema.extend("string", (data) => { | ||
| if (typeof data === "string") | ||
| return [data]; | ||
| throw new TypeError(`expected string but got ${data}`); | ||
| function checkWithinRange(data, meta, description) { | ||
| const { max = Infinity, min = -Infinity } = meta; | ||
| if (data > max) | ||
| throw new TypeError(`expected ${description} <= ${max} but got ${data}`); | ||
| if (data < min) | ||
| throw new TypeError(`expected ${description} >= ${min} but got ${data}`); | ||
| } | ||
| __name(checkWithinRange, "checkWithinRange"); | ||
| Schema.extend("string", (data, { meta }) => { | ||
| if (typeof data !== "string") | ||
| throw new TypeError(`expected string but got ${data}`); | ||
| checkWithinRange(data.length, meta, "string length"); | ||
| return [data]; | ||
| }); | ||
| Schema.extend("number", (data, { meta }) => { | ||
| var _a; | ||
| const { max = Infinity, min = -Infinity, step } = meta; | ||
| if (typeof data !== "number") | ||
| throw new TypeError(`expected number but got ${data}`); | ||
| if (data > max) | ||
| throw new TypeError(`expected number <= ${max} but got ${data}`); | ||
| if (data < min) | ||
| throw new TypeError(`expected number >= ${min} but got ${data}`); | ||
| checkWithinRange(data, meta, "number"); | ||
| const { step } = meta; | ||
| if (step) { | ||
@@ -231,5 +237,6 @@ const quotient = Math.abs(data - ((_a = meta.min) != null ? _a : 0)) % step; | ||
| __name(property, "property"); | ||
| Schema.extend("array", (data, { inner }) => { | ||
| Schema.extend("array", (data, { inner, meta }) => { | ||
| if (!Array.isArray(data)) | ||
| throw new TypeError(`expected array but got ${data}`); | ||
| checkWithinRange(data.length, meta, "array length"); | ||
| return [data.map((_, index2) => property(data, index2, inner))]; | ||
@@ -236,0 +243,0 @@ }); |
| { | ||
| "name": "schemastery", | ||
| "description": "type driven schema validator", | ||
| "version": "3.1.1", | ||
| "version": "3.2.0", | ||
| "main": "index.js", | ||
@@ -32,8 +32,8 @@ "module": "lib/browser.js", | ||
| "chai": "^4.3.6", | ||
| "esbuild": "^0.13.15", | ||
| "esbuild": "^0.14.31", | ||
| "esbuild-register": "^3.3.2", | ||
| "mocha": "^9.2.1", | ||
| "mocha": "^9.2.2", | ||
| "rimraf": "^3.0.2", | ||
| "typescript": "^4.6.2" | ||
| "typescript": "^4.6.3" | ||
| } | ||
| } |
Sorry, the diff of this file is not supported yet
No alert changes
Worsened metrics
- Total package byte prevSize
- decreased by-4.73%
85690
- Lines of code
- decreased by-38%
527
No dependency changes