// To parse this data://// import { Convert, MyType } from "./file";//// const myType = Convert.toMyType(json);//// These functions will throw an error if the JSON doesn't// match the expected interface, even if the JSON is valid.exportinterfaceMyType { a: string; arr: number[]; nested: Nested; } exportinterfaceNested { a: number; b: string; } // Converts JSON strings to/from your types// and asserts the results of JSON.parse at runtimeexportclassConvert { publicstatictoMyType(json: string): MyType { returncast(JSON.parse(json), r("MyType")); } publicstaticmyTypeToJson(value: MyType): string { returnJSON.stringify(uncast(value, r("MyType")), null, 2); } } functioninvalidValue(typ: any, val: any, key: any, parent: any = ''): never { const prettyTyp = prettyTypeName(typ); const parentText = parent ? ` on ${parent}` : ''; const keyText = key ? ` for key "${key}"` : ''; throwError(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); } functionprettyTypeName(typ: any): string { if (Array.isArray(typ)) { if (typ.length === 2 && typ[0] === undefined) { return`an optional ${prettyTypeName(typ[1])}`; } else { return`one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; } } elseif (typeof typ === "object" && typ.literal !== undefined) { return typ.literal; } else { returntypeof typ; } } functionjsonToJSProps(typ: any): any { if (typ.jsonToJS === undefined) { constmap: any = {}; typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); typ.jsonToJS = map; } return typ.jsonToJS; } functionjsToJSONProps(typ: any): any { if (typ.jsToJSON === undefined) { constmap: any = {}; typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); typ.jsToJSON = map; } return typ.jsToJSON; } functiontransform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { functiontransformPrimitive(typ: string, val: any): any { if (typeof typ === typeof val) return val; returninvalidValue(typ, val, key, parent); } functiontransformUnion(typs: any[], val: any): any { // val must validate against one typ in typsconst l = typs.length; for (let i = 0; i < l; i++) { const typ = typs[i]; try { returntransform(val, typ, getProps); } catch (_) {} } returninvalidValue(typs, val, key, parent); } functiontransformEnum(cases: string[], val: any): any { if (cases.indexOf(val) !== -1) return val; returninvalidValue(cases.map(a => { returnl(a); }), val, key, parent); } functiontransformArray(typ: any, val: any): any { // val must be an array with no invalid elementsif (!Array.isArray(val)) returninvalidValue(l("array"), val, key, parent); return val.map(el =>transform(el, typ, getProps)); } functiontransformDate(val: any): any { if (val === null) { returnnull; } const d = newDate(val); if (isNaN(d.valueOf())) { returninvalidValue(l("Date"), val, key, parent); } return d; } functiontransformObject(props: { [k: string]: any }, additional: any, val: any): any { if (val === null || typeof val !== "object" || Array.isArray(val)) { returninvalidValue(l(ref || "object"), val, key, parent); } constresult: any = {}; Object.getOwnPropertyNames(props).forEach(key => { const prop = props[key]; const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; result[prop.key] = transform(v, prop.typ, getProps, key, ref); }); Object.getOwnPropertyNames(val).forEach(key => { if (!Object.prototype.hasOwnProperty.call(props, key)) { result[key] = transform(val[key], additional, getProps, key, ref); } }); return result; } if (typ === "any") return val; if (typ === null) { if (val === null) return val; returninvalidValue(typ, val, key, parent); } if (typ === false) returninvalidValue(typ, val, key, parent); letref: any = undefined; while (typeof typ === "object" && typ.ref !== undefined) { ref = typ.ref; typ = typeMap[typ.ref]; } if (Array.isArray(typ)) returntransformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) : invalidValue(typ, val, key, parent); } // Numbers can be parsed by Date but shouldn't be.if (typ === Date && typeof val !== "number") returntransformDate(val); returntransformPrimitive(typ, val); } function cast<T>(val: any, typ: any): T { returntransform(val, typ, jsonToJSProps); } function uncast<T>(val: T, typ: any): any { returntransform(val, typ, jsToJSONProps); } functionl(typ: any) { return { literal: typ }; } functiona(typ: any) { return { arrayItems: typ }; } functionu(...typs: any[]) { return { unionMembers: typs }; } functiono(props: any[], additional: any) { return { props, additional }; } functionm(additional: any) { return { props: [], additional }; } functionr(name: string) { return { ref: name }; } consttypeMap: any = { "MyType": o([ { json: "a", js: "a", typ: "" }, { json: "arr", js: "arr", typ: a(0) }, { json: "nested", js: "nested", typ: r("Nested") }, ], false), "Nested": o([ { json: "a", js: "a", typ: 0 }, { json: "b", js: "b", typ: "" }, ], false), };