diff --git a/implementations/javascript/packages/schema/package.json b/implementations/javascript/packages/schema/package.json index 29fd700..7e619bf 100644 --- a/implementations/javascript/packages/schema/package.json +++ b/implementations/javascript/packages/schema/package.json @@ -13,14 +13,14 @@ "types": "lib/index.d.ts", "author": "Tony Garnock-Jones ", "scripts": { - "regenerate": "rm -rf ./src/gen && yarn copy-schema && ../schema-cli/bin/preserves-schema-ts.js --output ./src/gen ./dist:schema.prs", + "regenerate": "rm -rf ./src/gen && yarn copy-schema && ../schema-cli/bin/preserves-schema-ts.js --output ./src/gen ./dist:*.prs", "clean": "rm -rf lib dist", "prepare": "yarn compile && yarn rollup && yarn copy-schema", "compile": "tsc", "compile:watch": "yarn compile -w", "rollup": "rollup -c", "rollup:watch": "yarn rollup -w", - "copy-schema": "mkdir -p ./dist && cp -a ../../../../schema/schema.prs ./dist", + "copy-schema": "mkdir -p ./dist && cp -a ../../../../schema/*.prs ./dist", "test": "jest", "test:watch": "jest --watch", "veryclean": "yarn run clean && rm -rf node_modules" diff --git a/implementations/javascript/packages/schema/src/gen/host.ts b/implementations/javascript/packages/schema/src/gen/host.ts new file mode 100644 index 0000000..c239ecd --- /dev/null +++ b/implementations/javascript/packages/schema/src/gen/host.ts @@ -0,0 +1,704 @@ +import * as _ from "@preserves/core"; +import * as _i_schema from "./schema"; + +export const $any = _.Symbol.for("any"); +export const $array = _.Symbol.for("array"); +export const $embedded = _.Symbol.for("embedded"); +export const $map = _.Symbol.for("map"); +export const $rec = _.Symbol.for("rec"); +export const $ref = _.Symbol.for("ref"); +export const $set = _.Symbol.for("set"); +export const $union = _.Symbol.for("union"); +export const $unit = _.Symbol.for("unit"); + +let __schema: _.Value | null = null; + +export function _schema() { + if (__schema === null) { + __schema = _.decode<_.GenericEmbedded>(_.Bytes.fromHex("b4b306736368656d61b7b30776657273696f6eb00101b30b646566696e6974696f6e73b7b3054669656c64b4b3026f72b5b5b104756e6974b4b3036c6974b304756e69748484b5b103616e79b4b3036c6974b303616e798484b5b108656d626564646564b4b3036c6974b308656d6265646465648484b5b1056172726179b4b303726563b4b3036c6974b305617272617984b4b3057475706c65b5b4b3056e616d6564b307656c656d656e74b4b303726566b584b3054669656c64848484848484b5b103736574b4b303726563b4b3036c6974b30373657484b4b3057475706c65b5b4b3056e616d6564b307656c656d656e74b4b303726566b584b3054669656c64848484848484b5b1036d6170b4b303726563b4b3036c6974b3036d617084b4b3057475706c65b5b4b3056e616d6564b3036b6579b4b303726566b584b3054669656c648484b4b3056e616d6564b30576616c7565b4b303726566b584b3054669656c64848484848484b5b103726566b4b303726563b4b3036c6974b30372656684b4b3057475706c65b5b4b3056e616d6564b3046e616d65b4b303726566b5b306736368656d6184b303526566848484848484b5b10841746f6d4b696e64b4b303726566b5b306736368656d6184b30841746f6d4b696e6484848484b3065265636f7264b4b303726563b4b3036c6974b30372656384b4b3057475706c65b5b4b3056e616d6564b3066669656c6473b4b3057365716f66b4b303726566b584b30a4e616d65644669656c64848484848484b30653696d706c65b4b3026f72b5b5b1054669656c64b4b303726566b584b3054669656c648484b5b1065265636f7264b4b303726566b584b3065265636f726484848484b30756617269616e74b4b3057475706c65b5b4b3056e616d6564b3056c6162656cb4b30461746f6db30653796d626f6c8484b4b3056e616d6564b30474797065b4b303726566b584b30653696d706c6584848484b30a446566696e6974696f6eb4b3026f72b5b5b105756e696f6eb4b303726563b4b3036c6974b305756e696f6e84b4b3057475706c65b5b4b3056e616d6564b30876617269616e7473b4b3057365716f66b4b303726566b584b30756617269616e7484848484848484b5b10653696d706c65b4b303726566b584b30653696d706c6584848484b30a4e616d65644669656c64b4b3057475706c65b5b4b3056e616d6564b3046e616d65b4b30461746f6db30653796d626f6c8484b4b3056e616d6564b30474797065b4b303726566b584b3054669656c648484848484b30c656d62656464656454797065808484")); + }; + return __schema; +} + +export const _imports = {"schema": _i_schema} + + +export type Definition = ( + ( + {"_variant": "union", "variants": Array} | + {"_variant": "Simple", "value": Simple} + ) & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + +export type Variant = ( + {"label": symbol, "type": Simple} & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + +export type Simple = ( + ( + {"_variant": "Field", "value": Field} | + {"_variant": "Record", "value": Record} + ) & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + +export type Record = ( + {"fields": Array} & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + +export type NamedField = ( + {"name": symbol, "type": Field} & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + +export type Field = ( + ( + {"_variant": "unit"} | + {"_variant": "any"} | + {"_variant": "embedded"} | + {"_variant": "array", "element": Field} | + {"_variant": "set", "element": Field} | + {"_variant": "map", "key": Field, "value": Field} | + {"_variant": "ref", "name": _i_schema.Ref} | + {"_variant": "AtomKind", "value": _i_schema.AtomKind} + ) & + _.Preservable & + _.PreserveWritable & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +); + + +export namespace Definition { + export function union(variants: Array): Definition { + return { + "_variant": "union", + "variants": variants, + __as_preserve__() {return fromDefinition(this);}, + __preserve_on__(e) { e.push(fromDefinition(this)); }, + __preserve_text_on__(w) { w.push(fromDefinition(this)); } + }; + }; + union.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Definition"), + variant: _.Symbol.for("union") + }; + }; + export function Simple(value: Simple): Definition { + return { + "_variant": "Simple", + "value": value, + __as_preserve__() {return fromDefinition(this);}, + __preserve_on__(e) { e.push(fromDefinition(this)); }, + __preserve_text_on__(w) { w.push(fromDefinition(this)); } + }; + }; + Simple.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Definition"), + variant: _.Symbol.for("Simple") + }; + }; +} + +export function Variant({label, type}: {label: symbol, type: Simple}): Variant { + return { + "label": label, + "type": type, + __as_preserve__() {return fromVariant(this);}, + __preserve_on__(e) { e.push(fromVariant(this)); }, + __preserve_text_on__(w) { w.push(fromVariant(this)); } + }; +} + +Variant.schema = function () { + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Variant")}; +} + +export namespace Simple { + export function Field(value: Field): Simple { + return { + "_variant": "Field", + "value": value, + __as_preserve__() {return fromSimple(this);}, + __preserve_on__(e) { e.push(fromSimple(this)); }, + __preserve_text_on__(w) { w.push(fromSimple(this)); } + }; + }; + Field.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Simple"), + variant: _.Symbol.for("Field") + }; + }; + export function Record(value: Record): Simple { + return { + "_variant": "Record", + "value": value, + __as_preserve__() {return fromSimple(this);}, + __preserve_on__(e) { e.push(fromSimple(this)); }, + __preserve_text_on__(w) { w.push(fromSimple(this)); } + }; + }; + Record.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Simple"), + variant: _.Symbol.for("Record") + }; + }; +} + +export function Record(fields: Array): Record { + return { + "fields": fields, + __as_preserve__() {return fromRecord(this);}, + __preserve_on__(e) { e.push(fromRecord(this)); }, + __preserve_text_on__(w) { w.push(fromRecord(this)); } + }; +} + +Record.schema = function () { + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Record")}; +} + +export function NamedField({name, type}: {name: symbol, type: Field}): NamedField { + return { + "name": name, + "type": type, + __as_preserve__() {return fromNamedField(this);}, + __preserve_on__(e) { e.push(fromNamedField(this)); }, + __preserve_text_on__(w) { w.push(fromNamedField(this)); } + }; +} + +NamedField.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("NamedField") + }; +} + +export namespace Field { + export function unit(): Field { + return { + "_variant": "unit", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + unit.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("unit") + }; + }; + export function any(): Field { + return { + "_variant": "any", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + any.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("any") + }; + }; + export function embedded(): Field { + return { + "_variant": "embedded", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + embedded.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("embedded") + }; + }; + export function array(element: Field): Field { + return { + "_variant": "array", + "element": element, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + array.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("array") + }; + }; + export function set(element: Field): Field { + return { + "_variant": "set", + "element": element, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + set.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("set") + }; + }; + export function map({key, value}: {key: Field, value: Field}): Field { + return { + "_variant": "map", + "key": key, + "value": value, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + map.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("map") + }; + }; + export function ref(name: _i_schema.Ref): Field { + return { + "_variant": "ref", + "name": name, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + ref.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("ref") + }; + }; + export function AtomKind(value: _i_schema.AtomKind): Field { + return { + "_variant": "AtomKind", + "value": value, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + AtomKind.schema = function () { + return { + schema: _schema(), + imports: _imports, + definitionName: _.Symbol.for("Field"), + variant: _.Symbol.for("AtomKind") + }; + }; +} + +export function asDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Definition { + let result = toDefinition(v); + if (result === void 0) throw new TypeError(`Invalid Definition: ${_.stringify(v)}`); + return result; +} + +export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition { + let result: undefined | Definition; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $union) ? {} : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Array) | undefined; + _tmp1 = void 0; + if (_.isSequence(v[0])) { + _tmp1 = []; + for (const _tmp2 of v[0]) { + let _tmp3: (Variant) | undefined; + _tmp3 = toVariant(_tmp2); + if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;}; + _tmp1 = void 0; + break; + }; + }; + if (_tmp1 !== void 0) { + result = { + "_variant": "union", + "variants": _tmp1, + __as_preserve__() {return fromDefinition(this);}, + __preserve_on__(e) { e.push(fromDefinition(this)); }, + __preserve_text_on__(w) { w.push(fromDefinition(this)); } + }; + }; + }; + }; + if (result === void 0) { + let _tmp4: (Simple) | undefined; + _tmp4 = toSimple(v); + if (_tmp4 !== void 0) { + result = { + "_variant": "Simple", + "value": _tmp4, + __as_preserve__() {return fromDefinition(this);}, + __preserve_on__(e) { e.push(fromDefinition(this)); }, + __preserve_text_on__(w) { w.push(fromDefinition(this)); } + }; + }; + }; + return result; +} + +export namespace Definition {export const __from_preserve__ = toDefinition;} + +export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition): _.Value<_embedded> { + switch (_v._variant) { + case "union": {return _.Record($union, [_v["variants"].map(v => fromVariant<_embedded>(v))]);}; + case "Simple": {return fromSimple<_embedded>(_v.value);}; + }; +} + +export function asVariant<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Variant { + let result = toVariant(v); + if (result === void 0) throw new TypeError(`Invalid Variant: ${_.stringify(v)}`); + return result; +} + +export function toVariant<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Variant { + let result: undefined | Variant; + if (_.isSequence(v) && v.length === 2) { + let _tmp0: (symbol) | undefined; + _tmp0 = typeof v[0] === 'symbol' ? v[0] : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Simple) | undefined; + _tmp1 = toSimple(v[1]); + if (_tmp1 !== void 0) { + result = { + "label": _tmp0, + "type": _tmp1, + __as_preserve__() {return fromVariant(this);}, + __preserve_on__(e) { e.push(fromVariant(this)); }, + __preserve_text_on__(w) { w.push(fromVariant(this)); } + }; + }; + }; + }; + return result; +} + +Variant.__from_preserve__ = toVariant; + +export function fromVariant<_embedded = _.GenericEmbedded>(_v: Variant): _.Value<_embedded> {return [_v["label"], fromSimple<_embedded>(_v["type"])];} + +export function asSimple<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Simple { + let result = toSimple(v); + if (result === void 0) throw new TypeError(`Invalid Simple: ${_.stringify(v)}`); + return result; +} + +export function toSimple<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Simple { + let _tmp0: (Field) | undefined; + let result: undefined | Simple; + _tmp0 = toField(v); + if (_tmp0 !== void 0) { + result = { + "_variant": "Field", + "value": _tmp0, + __as_preserve__() {return fromSimple(this);}, + __preserve_on__(e) { e.push(fromSimple(this)); }, + __preserve_text_on__(w) { w.push(fromSimple(this)); } + }; + }; + if (result === void 0) { + let _tmp1: (Record) | undefined; + _tmp1 = toRecord(v); + if (_tmp1 !== void 0) { + result = { + "_variant": "Record", + "value": _tmp1, + __as_preserve__() {return fromSimple(this);}, + __preserve_on__(e) { e.push(fromSimple(this)); }, + __preserve_text_on__(w) { w.push(fromSimple(this)); } + }; + }; + }; + return result; +} + +export namespace Simple {export const __from_preserve__ = toSimple;} + +export function fromSimple<_embedded = _.GenericEmbedded>(_v: Simple): _.Value<_embedded> { + switch (_v._variant) { + case "Field": {return fromField<_embedded>(_v.value);}; + case "Record": {return fromRecord<_embedded>(_v.value);}; + }; +} + +export function asRecord<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Record { + let result = toRecord(v); + if (result === void 0) throw new TypeError(`Invalid Record: ${_.stringify(v)}`); + return result; +} + +export function toRecord<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Record { + let result: undefined | Record; + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $rec) ? {} : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Array) | undefined; + _tmp1 = void 0; + if (_.isSequence(v[0])) { + _tmp1 = []; + for (const _tmp2 of v[0]) { + let _tmp3: (NamedField) | undefined; + _tmp3 = toNamedField(_tmp2); + if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;}; + _tmp1 = void 0; + break; + }; + }; + if (_tmp1 !== void 0) { + result = { + "fields": _tmp1, + __as_preserve__() {return fromRecord(this);}, + __preserve_on__(e) { e.push(fromRecord(this)); }, + __preserve_text_on__(w) { w.push(fromRecord(this)); } + }; + }; + }; + }; + return result; +} + +Record.__from_preserve__ = toRecord; + +export function fromRecord<_embedded = _.GenericEmbedded>(_v: Record): _.Value<_embedded> {return _.Record($rec, [_v["fields"].map(v => fromNamedField<_embedded>(v))]);} + +export function asNamedField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedField { + let result = toNamedField(v); + if (result === void 0) throw new TypeError(`Invalid NamedField: ${_.stringify(v)}`); + return result; +} + +export function toNamedField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedField { + let result: undefined | NamedField; + if (_.isSequence(v) && v.length === 2) { + let _tmp0: (symbol) | undefined; + _tmp0 = typeof v[0] === 'symbol' ? v[0] : void 0; + if (_tmp0 !== void 0) { + let _tmp1: (Field) | undefined; + _tmp1 = toField(v[1]); + if (_tmp1 !== void 0) { + result = { + "name": _tmp0, + "type": _tmp1, + __as_preserve__() {return fromNamedField(this);}, + __preserve_on__(e) { e.push(fromNamedField(this)); }, + __preserve_text_on__(w) { w.push(fromNamedField(this)); } + }; + }; + }; + }; + return result; +} + +NamedField.__from_preserve__ = toNamedField; + +export function fromNamedField<_embedded = _.GenericEmbedded>(_v: NamedField): _.Value<_embedded> {return [_v["name"], fromField<_embedded>(_v["type"])];} + +export function asField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Field { + let result = toField(v); + if (result === void 0) throw new TypeError(`Invalid Field: ${_.stringify(v)}`); + return result; +} + +export function toField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Field { + let _tmp0: ({}) | undefined; + let result: undefined | Field; + _tmp0 = _.is(v, $unit) ? {} : void 0; + if (_tmp0 !== void 0) { + result = { + "_variant": "unit", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + if (result === void 0) { + let _tmp1: ({}) | undefined; + _tmp1 = _.is(v, $any) ? {} : void 0; + if (_tmp1 !== void 0) { + result = { + "_variant": "any", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + if (result === void 0) { + let _tmp2: ({}) | undefined; + _tmp2 = _.is(v, $embedded) ? {} : void 0; + if (_tmp2 !== void 0) { + result = { + "_variant": "embedded", + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp3: ({}) | undefined; + _tmp3 = _.is(v.label, $array) ? {} : void 0; + if (_tmp3 !== void 0) { + let _tmp4: (Field) | undefined; + _tmp4 = toField(v[0]); + if (_tmp4 !== void 0) { + result = { + "_variant": "array", + "element": _tmp4, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp5: ({}) | undefined; + _tmp5 = _.is(v.label, $set) ? {} : void 0; + if (_tmp5 !== void 0) { + let _tmp6: (Field) | undefined; + _tmp6 = toField(v[0]); + if (_tmp6 !== void 0) { + result = { + "_variant": "set", + "element": _tmp6, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp7: ({}) | undefined; + _tmp7 = _.is(v.label, $map) ? {} : void 0; + if (_tmp7 !== void 0) { + let _tmp8: (Field) | undefined; + _tmp8 = toField(v[0]); + if (_tmp8 !== void 0) { + let _tmp9: (Field) | undefined; + _tmp9 = toField(v[1]); + if (_tmp9 !== void 0) { + result = { + "_variant": "map", + "key": _tmp8, + "value": _tmp9, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + }; + }; + }; + if (result === void 0) { + if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { + let _tmp10: ({}) | undefined; + _tmp10 = _.is(v.label, $ref) ? {} : void 0; + if (_tmp10 !== void 0) { + let _tmp11: (_i_schema.Ref) | undefined; + _tmp11 = _i_schema.toRef<_embedded>(v[0]); + if (_tmp11 !== void 0) { + result = { + "_variant": "ref", + "name": _tmp11, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + }; + }; + if (result === void 0) { + let _tmp12: (_i_schema.AtomKind) | undefined; + _tmp12 = _i_schema.toAtomKind<_embedded>(v); + if (_tmp12 !== void 0) { + result = { + "_variant": "AtomKind", + "value": _tmp12, + __as_preserve__() {return fromField(this);}, + __preserve_on__(e) { e.push(fromField(this)); }, + __preserve_text_on__(w) { w.push(fromField(this)); } + }; + }; + }; + }; + }; + }; + }; + }; + }; + return result; +} + +export namespace Field {export const __from_preserve__ = toField;} + +export function fromField<_embedded = _.GenericEmbedded>(_v: Field): _.Value<_embedded> { + switch (_v._variant) { + case "unit": {return $unit;}; + case "any": {return $any;}; + case "embedded": {return $embedded;}; + case "array": {return _.Record($array, [fromField<_embedded>(_v["element"])]);}; + case "set": {return _.Record($set, [fromField<_embedded>(_v["element"])]);}; + case "map": { + return _.Record($map, [fromField<_embedded>(_v["key"]), fromField<_embedded>(_v["value"])]); + }; + case "ref": {return _.Record($ref, [_i_schema.fromRef<_embedded>(_v["name"])]);}; + case "AtomKind": {return _i_schema.fromAtomKind<_embedded>(_v.value);}; + }; +} + diff --git a/implementations/javascript/packages/schema/src/host.ts b/implementations/javascript/packages/schema/src/host.ts new file mode 100644 index 0000000..6c93a1c --- /dev/null +++ b/implementations/javascript/packages/schema/src/host.ts @@ -0,0 +1,83 @@ +import { compare } from '@preserves/core'; + +import * as M from './meta'; +import * as H from './gen/host'; + +export * from './gen/host'; + +export function definitionType(p: M.Definition): H.Definition { + switch (p._variant) { + case 'or': return H.Definition.union([p.pattern0, p.pattern1, ... p.patternN].map(p => + H.Variant({ label: Symbol.for(p.variantLabel), type: patternType(p.pattern) }))); + case 'and': + return H.Definition.Simple(productType([p.pattern0, p.pattern1, ... p.patternN])); + case 'Pattern': + return H.Definition.Simple(patternType(p.value)); + } +} + +export function patternType(p: M.Pattern): H.Simple { + switch (p._variant) { + case 'SimplePattern': + return H.Simple.Field(fieldType(p.value)); + case 'CompoundPattern': + return productType([M.NamedPattern.anonymous(p)]); + } +} + +export function fieldType(p: M.SimplePattern): H.Field { + switch (p._variant) { + case 'any': return H.Field.any(); + case 'atom': return H.Field.AtomKind(p.atomKind); + case 'embedded': return H.Field.embedded(); + case 'lit': return H.Field.unit(); + case 'seqof': return H.Field.array(fieldType(p.pattern)); + case 'setof': return H.Field.set(fieldType(p.pattern)); + case 'dictof': return H.Field.map({ key: fieldType(p.key), value: fieldType(p.value) }); + case 'Ref': return H.Field.ref(p.value); + } +} + +export function productType(ps: M.NamedPattern[]): H.Simple { + const gathered: H.NamedField[] = []; + ps.forEach(p => gather(p, gathered)); + if (gathered.length === 0) return H.Simple.Field(H.Field.unit()); + return H.Simple.Record(H.Record(gathered)); +} + +function promote(p: M.NamedSimplePattern): M.NamedPattern { + if (p._variant === 'named') return p; + return M.NamedPattern.anonymous(M.Pattern.SimplePattern(p.value)); +} + +function gather(p: M.NamedPattern, into: H.NamedField[]) { + switch (p._variant) { + case 'named': { + const t = fieldType(p.value.pattern); + if (t._variant !== 'unit') into.push(H.NamedField({ name: p.value.name, type: t })); + break; + } + case 'anonymous': { + if (p.value._variant === 'SimplePattern') return; + const q = p.value.value; + switch (q._variant) { + case 'rec': + gather(q.label, into); + gather(q.fields, into); + break; + case 'tuple': + q.patterns.forEach(p => gather(p, into)); + break; + case 'tuplePrefix': + q.fixed.forEach(p => gather(p, into)); + gather(promote(q.variable), into); + break; + case 'dict': { + const items = Array.from(q.entries.entries()).sort((a, b) => compare(a[0], b[0])); + items.forEach(([_key, p]) => gather(promote(p), into)); + break; + } + } + } + } +} diff --git a/implementations/javascript/packages/schema/src/index.ts b/implementations/javascript/packages/schema/src/index.ts index 6acf951..19c012b 100644 --- a/implementations/javascript/packages/schema/src/index.ts +++ b/implementations/javascript/packages/schema/src/index.ts @@ -3,6 +3,8 @@ export * from './error'; export * from './reader'; export * from './compiler'; export * from './reflection'; + +export * as Host from './host'; export * as Meta from './meta'; export * as Type from './compiler/type'; export * as GenType from './compiler/gentype';