402 lines
18 KiB
TypeScript
402 lines
18 KiB
TypeScript
import * as _ from "@preserves/core";
|
|
import * as _i_EntityRef from "../runtime/actor";
|
|
|
|
export const $bytes = Symbol.for("bytes");
|
|
export const $credit = Symbol.for("credit");
|
|
export const $crlf = Symbol.for("crlf");
|
|
export const $data = Symbol.for("data");
|
|
export const $eof = Symbol.for("eof");
|
|
export const $error = Symbol.for("error");
|
|
export const $lf = Symbol.for("lf");
|
|
export const $object = Symbol.for("object");
|
|
export const $packet = Symbol.for("packet");
|
|
export const $sink = Symbol.for("sink");
|
|
export const $source = Symbol.for("source");
|
|
export const $unbounded = Symbol.for("unbounded");
|
|
export const __lit0 = Symbol.for("stream-connection");
|
|
export const __lit1 = Symbol.for("stream-listener-ready");
|
|
export const __lit2 = Symbol.for("stream-listener-error");
|
|
|
|
export type _embedded = _i_EntityRef.Ref;
|
|
|
|
export type StreamConnection<_embedded = _i_EntityRef.Ref> = {"source": _embedded, "sink": _embedded, "spec": _.Value<_embedded>};
|
|
|
|
export type StreamListenerReady<_embedded = _i_EntityRef.Ref> = {"spec": _.Value<_embedded>};
|
|
|
|
export type StreamListenerError<_embedded = _i_EntityRef.Ref> = {"spec": _.Value<_embedded>, "message": string};
|
|
|
|
export type StreamError = {"message": string};
|
|
|
|
export type Source<_embedded = _i_EntityRef.Ref> = (
|
|
{"_variant": "sink", "controller": _embedded} |
|
|
{"_variant": "StreamError", "value": StreamError} |
|
|
{"_variant": "credit", "amount": CreditAmount, "mode": Mode<_embedded>}
|
|
);
|
|
|
|
export type Sink<_embedded = _i_EntityRef.Ref> = (
|
|
{"_variant": "source", "controller": _embedded} |
|
|
{"_variant": "StreamError", "value": StreamError} |
|
|
{"_variant": "data", "payload": _.Value<_embedded>, "mode": Mode<_embedded>} |
|
|
{"_variant": "eof"}
|
|
);
|
|
|
|
export type CreditAmount = ({"_variant": "count", "value": number} | {"_variant": "unbounded"});
|
|
|
|
export type Mode<_embedded = _i_EntityRef.Ref> = (
|
|
{"_variant": "bytes"} |
|
|
{"_variant": "lines", "value": LineMode} |
|
|
{"_variant": "packet", "size": number} |
|
|
{"_variant": "object", "description": _.Value<_embedded>}
|
|
);
|
|
|
|
export type LineMode = ({"_variant": "lf"} | {"_variant": "crlf"});
|
|
|
|
|
|
export function StreamConnection<_embedded = _i_EntityRef.Ref>(
|
|
{source, sink, spec}: {source: _embedded, sink: _embedded, spec: _.Value<_embedded>}
|
|
): StreamConnection<_embedded> {return {"source": source, "sink": sink, "spec": spec};}
|
|
|
|
export function StreamListenerReady<_embedded = _i_EntityRef.Ref>(spec: _.Value<_embedded>): StreamListenerReady<_embedded> {return {"spec": spec};}
|
|
|
|
export function StreamListenerError<_embedded = _i_EntityRef.Ref>({spec, message}: {spec: _.Value<_embedded>, message: string}): StreamListenerError<_embedded> {return {"spec": spec, "message": message};}
|
|
|
|
export function StreamError(message: string): StreamError {return {"message": message};}
|
|
|
|
export namespace Source {
|
|
export function sink<_embedded = _i_EntityRef.Ref>(controller: _embedded): Source<_embedded> {return {"_variant": "sink", "controller": controller};};
|
|
export function StreamError<_embedded = _i_EntityRef.Ref>(value: StreamError): Source<_embedded> {return {"_variant": "StreamError", "value": value};};
|
|
export function credit<_embedded = _i_EntityRef.Ref>({amount, mode}: {amount: CreditAmount, mode: Mode<_embedded>}): Source<_embedded> {return {"_variant": "credit", "amount": amount, "mode": mode};};
|
|
}
|
|
|
|
export namespace Sink {
|
|
export function source<_embedded = _i_EntityRef.Ref>(controller: _embedded): Sink<_embedded> {return {"_variant": "source", "controller": controller};};
|
|
export function StreamError<_embedded = _i_EntityRef.Ref>(value: StreamError): Sink<_embedded> {return {"_variant": "StreamError", "value": value};};
|
|
export function data<_embedded = _i_EntityRef.Ref>({payload, mode}: {payload: _.Value<_embedded>, mode: Mode<_embedded>}): Sink<_embedded> {return {"_variant": "data", "payload": payload, "mode": mode};};
|
|
export function eof<_embedded = _i_EntityRef.Ref>(): Sink<_embedded> {return {"_variant": "eof"};};
|
|
}
|
|
|
|
export namespace CreditAmount {
|
|
export function count(value: number): CreditAmount {return {"_variant": "count", "value": value};};
|
|
export function unbounded(): CreditAmount {return {"_variant": "unbounded"};};
|
|
}
|
|
|
|
export namespace Mode {
|
|
export function bytes<_embedded = _i_EntityRef.Ref>(): Mode<_embedded> {return {"_variant": "bytes"};};
|
|
export function lines<_embedded = _i_EntityRef.Ref>(value: LineMode): Mode<_embedded> {return {"_variant": "lines", "value": value};};
|
|
export function packet<_embedded = _i_EntityRef.Ref>(size: number): Mode<_embedded> {return {"_variant": "packet", "size": size};};
|
|
export function object<_embedded = _i_EntityRef.Ref>(description: _.Value<_embedded>): Mode<_embedded> {return {"_variant": "object", "description": description};};
|
|
}
|
|
|
|
export namespace LineMode {
|
|
export function lf(): LineMode {return {"_variant": "lf"};};
|
|
export function crlf(): LineMode {return {"_variant": "crlf"};};
|
|
}
|
|
|
|
export function asStreamConnection<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamConnection<_embedded> {
|
|
let result = toStreamConnection(v);
|
|
if (result === void 0) throw new TypeError(`Invalid StreamConnection: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toStreamConnection<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamConnection<_embedded> {
|
|
let result: undefined | StreamConnection<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, __lit0) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_embedded) | undefined;
|
|
_tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
|
|
if (_tmp1 !== void 0) {
|
|
let _tmp2: (_embedded) | undefined;
|
|
_tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0;
|
|
if (_tmp2 !== void 0) {
|
|
let _tmp3: (_.Value<_embedded>) | undefined;
|
|
_tmp3 = v[2];
|
|
if (_tmp3 !== void 0) {result = {"source": _tmp1, "sink": _tmp2, "spec": _tmp3};};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromStreamConnection<_embedded = _i_EntityRef.Ref>(_v: StreamConnection<_embedded>): _.Value<_embedded> {
|
|
return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["sink"]), _v["spec"]]);
|
|
}
|
|
|
|
export function asStreamListenerReady<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamListenerReady<_embedded> {
|
|
let result = toStreamListenerReady(v);
|
|
if (result === void 0) throw new TypeError(`Invalid StreamListenerReady: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toStreamListenerReady<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamListenerReady<_embedded> {
|
|
let result: undefined | StreamListenerReady<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, __lit1) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_.Value<_embedded>) | undefined;
|
|
_tmp1 = v[0];
|
|
if (_tmp1 !== void 0) {result = {"spec": _tmp1};};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromStreamListenerReady<_embedded = _i_EntityRef.Ref>(_v: StreamListenerReady<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["spec"]]);}
|
|
|
|
export function asStreamListenerError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamListenerError<_embedded> {
|
|
let result = toStreamListenerError(v);
|
|
if (result === void 0) throw new TypeError(`Invalid StreamListenerError: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toStreamListenerError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamListenerError<_embedded> {
|
|
let result: undefined | StreamListenerError<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, __lit2) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_.Value<_embedded>) | undefined;
|
|
_tmp1 = v[0];
|
|
if (_tmp1 !== void 0) {
|
|
let _tmp2: (string) | undefined;
|
|
_tmp2 = typeof v[1] === 'string' ? v[1] : void 0;
|
|
if (_tmp2 !== void 0) {result = {"spec": _tmp1, "message": _tmp2};};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromStreamListenerError<_embedded = _i_EntityRef.Ref>(_v: StreamListenerError<_embedded>): _.Value<_embedded> {return _.Record(__lit2, [_v["spec"], _v["message"]]);}
|
|
|
|
export function asStreamError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): StreamError {
|
|
let result = toStreamError(v);
|
|
if (result === void 0) throw new TypeError(`Invalid StreamError: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toStreamError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | StreamError {
|
|
let result: undefined | StreamError;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $error) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (string) | undefined;
|
|
_tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
|
|
if (_tmp1 !== void 0) {result = {"message": _tmp1};};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromStreamError<_embedded = _i_EntityRef.Ref>(_v: StreamError): _.Value<_embedded> {return _.Record($error, [_v["message"]]);}
|
|
|
|
export function asSource<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Source<_embedded> {
|
|
let result = toSource(v);
|
|
if (result === void 0) throw new TypeError(`Invalid Source: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toSource<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Source<_embedded> {
|
|
let result: undefined | Source<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $sink) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_embedded) | undefined;
|
|
_tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
|
|
if (_tmp1 !== void 0) {result = {"_variant": "sink", "controller": _tmp1};};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
let _tmp2: (StreamError) | undefined;
|
|
_tmp2 = toStreamError(v);
|
|
if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp3: (null) | undefined;
|
|
_tmp3 = _.is(v.label, $credit) ? null : void 0;
|
|
if (_tmp3 !== void 0) {
|
|
let _tmp4: (CreditAmount) | undefined;
|
|
_tmp4 = toCreditAmount(v[0]);
|
|
if (_tmp4 !== void 0) {
|
|
let _tmp5: (Mode<_embedded>) | undefined;
|
|
_tmp5 = toMode(v[1]);
|
|
if (_tmp5 !== void 0) {result = {"_variant": "credit", "amount": _tmp4, "mode": _tmp5};};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromSource<_embedded = _i_EntityRef.Ref>(_v: Source<_embedded>): _.Value<_embedded> {
|
|
switch (_v._variant) {
|
|
case "sink": {return _.Record($sink, [_.embed(_v["controller"])]);};
|
|
case "StreamError": {return fromStreamError<_embedded>(_v.value);};
|
|
case "credit": {
|
|
return _.Record(
|
|
$credit,
|
|
[fromCreditAmount<_embedded>(_v["amount"]), fromMode<_embedded>(_v["mode"])]
|
|
);
|
|
};
|
|
};
|
|
}
|
|
|
|
export function asSink<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Sink<_embedded> {
|
|
let result = toSink(v);
|
|
if (result === void 0) throw new TypeError(`Invalid Sink: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toSink<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Sink<_embedded> {
|
|
let result: undefined | Sink<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $source) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_embedded) | undefined;
|
|
_tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
|
|
if (_tmp1 !== void 0) {result = {"_variant": "source", "controller": _tmp1};};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
let _tmp2: (StreamError) | undefined;
|
|
_tmp2 = toStreamError(v);
|
|
if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp3: (null) | undefined;
|
|
_tmp3 = _.is(v.label, $data) ? null : void 0;
|
|
if (_tmp3 !== void 0) {
|
|
let _tmp4: (_.Value<_embedded>) | undefined;
|
|
_tmp4 = v[0];
|
|
if (_tmp4 !== void 0) {
|
|
let _tmp5: (Mode<_embedded>) | undefined;
|
|
_tmp5 = toMode(v[1]);
|
|
if (_tmp5 !== void 0) {result = {"_variant": "data", "payload": _tmp4, "mode": _tmp5};};
|
|
};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp6: (null) | undefined;
|
|
_tmp6 = _.is(v.label, $eof) ? null : void 0;
|
|
if (_tmp6 !== void 0) {result = {"_variant": "eof"};};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromSink<_embedded = _i_EntityRef.Ref>(_v: Sink<_embedded>): _.Value<_embedded> {
|
|
switch (_v._variant) {
|
|
case "source": {return _.Record($source, [_.embed(_v["controller"])]);};
|
|
case "StreamError": {return fromStreamError<_embedded>(_v.value);};
|
|
case "data": {return _.Record($data, [_v["payload"], fromMode<_embedded>(_v["mode"])]);};
|
|
case "eof": {return _.Record($eof, []);};
|
|
};
|
|
}
|
|
|
|
export function asCreditAmount<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CreditAmount {
|
|
let result = toCreditAmount(v);
|
|
if (result === void 0) throw new TypeError(`Invalid CreditAmount: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toCreditAmount<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CreditAmount {
|
|
let _tmp0: (number) | undefined;
|
|
let result: undefined | CreditAmount;
|
|
_tmp0 = typeof v === 'number' ? v : void 0;
|
|
if (_tmp0 !== void 0) {result = {"_variant": "count", "value": _tmp0};};
|
|
if (result === void 0) {
|
|
let _tmp1: (null) | undefined;
|
|
_tmp1 = _.is(v, $unbounded) ? null : void 0;
|
|
if (_tmp1 !== void 0) {result = {"_variant": "unbounded"};};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromCreditAmount<_embedded = _i_EntityRef.Ref>(_v: CreditAmount): _.Value<_embedded> {
|
|
switch (_v._variant) {case "count": {return _v.value;}; case "unbounded": {return $unbounded;};};
|
|
}
|
|
|
|
export function asMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Mode<_embedded> {
|
|
let result = toMode(v);
|
|
if (result === void 0) throw new TypeError(`Invalid Mode: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Mode<_embedded> {
|
|
let _tmp0: (null) | undefined;
|
|
let result: undefined | Mode<_embedded>;
|
|
_tmp0 = _.is(v, $bytes) ? null : void 0;
|
|
if (_tmp0 !== void 0) {result = {"_variant": "bytes"};};
|
|
if (result === void 0) {
|
|
let _tmp1: (LineMode) | undefined;
|
|
_tmp1 = toLineMode(v);
|
|
if (_tmp1 !== void 0) {result = {"_variant": "lines", "value": _tmp1};};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp2: (null) | undefined;
|
|
_tmp2 = _.is(v.label, $packet) ? null : void 0;
|
|
if (_tmp2 !== void 0) {
|
|
let _tmp3: (number) | undefined;
|
|
_tmp3 = typeof v[0] === 'number' ? v[0] : void 0;
|
|
if (_tmp3 !== void 0) {result = {"_variant": "packet", "size": _tmp3};};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp4: (null) | undefined;
|
|
_tmp4 = _.is(v.label, $object) ? null : void 0;
|
|
if (_tmp4 !== void 0) {
|
|
let _tmp5: (_.Value<_embedded>) | undefined;
|
|
_tmp5 = v[0];
|
|
if (_tmp5 !== void 0) {result = {"_variant": "object", "description": _tmp5};};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromMode<_embedded = _i_EntityRef.Ref>(_v: Mode<_embedded>): _.Value<_embedded> {
|
|
switch (_v._variant) {
|
|
case "bytes": {return $bytes;};
|
|
case "lines": {return fromLineMode<_embedded>(_v.value);};
|
|
case "packet": {return _.Record($packet, [_v["size"]]);};
|
|
case "object": {return _.Record($object, [_v["description"]]);};
|
|
};
|
|
}
|
|
|
|
export function asLineMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): LineMode {
|
|
let result = toLineMode(v);
|
|
if (result === void 0) throw new TypeError(`Invalid LineMode: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toLineMode<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | LineMode {
|
|
let _tmp0: (null) | undefined;
|
|
let result: undefined | LineMode;
|
|
_tmp0 = _.is(v, $lf) ? null : void 0;
|
|
if (_tmp0 !== void 0) {result = {"_variant": "lf"};};
|
|
if (result === void 0) {
|
|
let _tmp1: (null) | undefined;
|
|
_tmp1 = _.is(v, $crlf) ? null : void 0;
|
|
if (_tmp1 !== void 0) {result = {"_variant": "crlf"};};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromLineMode<_embedded = _i_EntityRef.Ref>(_v: LineMode): _.Value<_embedded> {
|
|
switch (_v._variant) {case "lf": {return $lf;}; case "crlf": {return $crlf;};};
|
|
}
|
|
|