Bring up to date (untested)
This commit is contained in:
parent
61c1a100d2
commit
2b5e5611b3
|
|
@ -0,0 +1,11 @@
|
|||
all:
|
||||
yarn run build
|
||||
|
||||
clean:
|
||||
yarn run clean
|
||||
|
||||
pull-protocols:
|
||||
git subtree pull -P protocols \
|
||||
-m 'Merge latest changes from the syndicate-protocols repository' \
|
||||
git@git.syndicate-lang.org:syndicate-lang/syndicate-protocols \
|
||||
main
|
||||
|
|
@ -10,14 +10,13 @@
|
|||
"@preserves/schema": "^0.16.0"
|
||||
},
|
||||
"scripts": {
|
||||
"regenerate": "rm -rf ./src/gen && preserves-schema-ts --module Actor=./src/runtime/actor.ts --output ./src/gen './schemas/**/*.prs'",
|
||||
"regenerate": "rm -rf ./src/gen && preserves-schema-ts --module EntityRef=./src/runtime/actor.ts --output ./src/gen './protocols/schemas/**/*.prs'",
|
||||
"regenerate:watch": "yarn regenerate --watch",
|
||||
"regenerate:bundle": "preserves-schemac './schemas/**/*.prs' > novy-syndicate.schema.bundle.bin",
|
||||
"compile": "tsc",
|
||||
"compile:watch": "tsc -w",
|
||||
"rollup": "rollup -c",
|
||||
"rollup:watch": "rollup -c -w",
|
||||
"clean": "rm -rf lib index.js",
|
||||
"build": "yarn regenerate && yarn regenerate:bundle && yarn compile && yarn rollup"
|
||||
"build": "yarn regenerate && yarn compile && yarn rollup"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
embeddedType EntityRef.Ref .
|
||||
|
||||
BoxState = <BoxState @value int>.
|
||||
SetBox = <SetBox @value int>.
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
;As implemented
|
||||
Observe = <Observe @label symbol @observer #!any>.
|
||||
|
||||
; ;As will be implemented soon
|
||||
; Observe = <Observe @pattern Pattern @observer #!any>.
|
||||
.
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
Resolve = <resolve @sturdyref sturdy.SturdyRef @observer #!#!any>.
|
||||
Bind = <bind @oid any @key bytes @target #!any>.
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType sturdy.WireRef .
|
||||
|
||||
Assertion = any .
|
||||
Handle = int .
|
||||
Event = Assert / Retract / Message / Sync .
|
||||
Oid = int .
|
||||
Turn = [TurnEvent ...].
|
||||
TurnEvent = [@oid Oid @event Event].
|
||||
|
||||
Assert = <assert @assertion Assertion @handle Handle>.
|
||||
Retract = <retract @handle Handle>.
|
||||
Message = <message @body Assertion>.
|
||||
Sync = <sync @peer #!#t>.
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
UserId = int .
|
||||
|
||||
Join = <joinedUser @uid UserId @handle #!Session>.
|
||||
|
||||
Session = @observeUsers <Observe =user @observer #!UserInfo>
|
||||
/ @observeSpeech <Observe =says @observer #!Says>
|
||||
/ NickClaim
|
||||
/ Says
|
||||
.
|
||||
|
||||
NickClaim = <claimNick @uid UserId @name string @k #!NickClaimResponse>.
|
||||
NickClaimResponse = #t / NickConflict .
|
||||
|
||||
UserInfo = <user @uid UserId @name string>.
|
||||
|
||||
Says = <says @who UserId @what string>.
|
||||
|
||||
NickConflict = <nickConflict>.
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
Present = <Present @username string>.
|
||||
Says = <Says @who string @what string>.
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
; Each Attenuation is a stage. The sequence of Attenuations is run RIGHT-TO-LEFT.
|
||||
; That is, the newest Attenuations are at the right.
|
||||
SturdyRef = <ref @oid any @caveatChain [Attenuation ...] @sig bytes>.
|
||||
|
||||
; An individual Attenuation is run RIGHT-TO-LEFT.
|
||||
; That is, the newest Caveats are at the right.
|
||||
Attenuation = [Caveat ...].
|
||||
|
||||
; embodies 1st-party caveats over assertion structure, but nothing else
|
||||
; can add 3rd-party caveats and richer predicates later
|
||||
Caveat = Rewrite / Alts .
|
||||
Rewrite = <rewrite @pattern Pattern @template Template>.
|
||||
Alts = <or @alternatives [Rewrite ...]>.
|
||||
|
||||
Oid = int .
|
||||
WireRef = @mine [0 @oid Oid] / @yours [1 @oid Oid @attenuation Caveat ...].
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
|
||||
ConstructorSpec = CRec / CArr / CDict .
|
||||
CRec = <rec @label any @arity int>.
|
||||
CArr = <arr @arity int>.
|
||||
CDict = <dict>.
|
||||
|
||||
Lit = <lit @value any>.
|
||||
|
||||
Pattern = PDiscard / PAtom / PEmbedded / PBind / PAnd / PNot / Lit / PCompound .
|
||||
PDiscard = <_>.
|
||||
PAtom = =Boolean / =Float / =Double / =SignedInteger / =String / =ByteString / =Symbol .
|
||||
PEmbedded = =Embedded .
|
||||
PBind = <bind @pattern Pattern>.
|
||||
PAnd = <and @patterns [Pattern ...]>.
|
||||
PNot = <not @pattern Pattern>.
|
||||
PCompound = <compound @ctor ConstructorSpec @members PCompoundMembers>.
|
||||
PCompoundMembers = { any: Pattern ...:... }.
|
||||
|
||||
Template = TAttenuate / TRef / Lit / TCompound .
|
||||
TAttenuate = <attenuate @template Template @attenuation Attenuation>.
|
||||
TRef = <ref @binding int>.
|
||||
TCompound = <compound @ctor ConstructorSpec @members TCompoundMembers>.
|
||||
TCompoundMembers = { any: Template ...:... }.
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
version 1 .
|
||||
embeddedType Actor.Ref .
|
||||
|
||||
Instance = <Instance @name string @argument any>.
|
||||
|
|
@ -1,14 +1,14 @@
|
|||
import { Actor, Handle, Turn } from '../runtime/actor.js';
|
||||
import { Dataspace, during, observe } from '../runtime/dataspace.js';
|
||||
import { Actor, Handle, Ref, Turn } from '../runtime/actor.js';
|
||||
import { Dataspace, during, observe, P } from '../runtime/dataspace.js';
|
||||
import { Relay, spawnRelay } from '../transport/relay.js';
|
||||
import * as net from 'net';
|
||||
|
||||
import { mint, sturdyEncode, validate } from '../transport/sturdy.js';
|
||||
import { KEY_LENGTH } from '../transport/cryptography.js';
|
||||
import { attenuate } from '../runtime/rewrite.js';
|
||||
import { Bytes, embed, is } from '@preserves/core';
|
||||
import { Attenuation, fromSturdyRef, _val } from '../gen/sturdy.js';
|
||||
import { $bind, Bind, fromBind, toBind, toResolve } from '../gen/gatekeeper.js';
|
||||
import { Bytes, embed, Embedded } from '@preserves/core';
|
||||
import { Attenuation, fromSturdyRef } from '../gen/sturdy.js';
|
||||
import { $bind, Bind, fromBind, toResolve } from '../gen/gatekeeper.js';
|
||||
|
||||
new Actor(t => {
|
||||
t.activeFacet.preventInertCheck();
|
||||
|
|
@ -44,18 +44,18 @@ new Actor(t => {
|
|||
if (a === void 0) return null;
|
||||
const r = a.sturdyref;
|
||||
let facet = t.facet(t => {
|
||||
observe(t, ds, $bind, during(async (t, b0) => {
|
||||
const b = toBind(b0);
|
||||
if (b === void 0) return null;
|
||||
if (!is(r.oid, b.oid)) return null;
|
||||
if (!await validate(r, b.key)) return null;
|
||||
const cavs: Attenuation = [];
|
||||
r.caveatChain.forEach(cs => cavs.push(... cs));
|
||||
const attenuated_ds = attenuate(b.target, ... cavs);
|
||||
let replyHandle: Handle | undefined;
|
||||
t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds)));
|
||||
return t => t.retract(replyHandle);
|
||||
}));
|
||||
observe(t, ds, P.rec($bind, P.lit(r.oid), P.bind('key'), P.bind('target')),
|
||||
during(async (t, bindings) => {
|
||||
const [key, embeddedTarget] = bindings as [Bytes, Embedded<Ref>];
|
||||
const target = embeddedTarget.embeddedValue;
|
||||
if (!await validate(r, key)) return null;
|
||||
const cavs: Attenuation = [];
|
||||
r.caveatChain.forEach(cs => cavs.push(... cs));
|
||||
const attenuated_ds = attenuate(target, ... cavs);
|
||||
let replyHandle: Handle | undefined;
|
||||
t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds)));
|
||||
return t => t.retract(replyHandle);
|
||||
}));
|
||||
});
|
||||
return t => t.stop(facet);
|
||||
})),
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
import { Embedded } from "@preserves/core";
|
||||
import { BoxState, $SetBox, fromBoxState } from "../gen/box-protocol.js";
|
||||
import { fromObserve, Observe } from "../gen/dataspace.js";
|
||||
import { BoxState, $SetBox, fromBoxState } from "../gen/examples/boxProtocol.js";
|
||||
import { fromObserve, Observe, P } from "../runtime/dataspace.js";
|
||||
import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
|
||||
|
||||
let startTime = Date.now();
|
||||
|
|
@ -18,7 +18,7 @@ export default function (t: Turn, arg: Assertion) {
|
|||
}
|
||||
setValue(t, 0);
|
||||
t.assert(ds, fromObserve(Observe({
|
||||
label: $SetBox,
|
||||
pattern: P.rec($SetBox, P.bind('newValue', P.discard())),
|
||||
observer: t.ref({
|
||||
message(t: Turn, [newValue]: [number]): void {
|
||||
// console.log(`Box ${t.actor.id}: got ${newValue}`);
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
import { Embedded } from "@preserves/core";
|
||||
import { $BoxState, fromSetBox, SetBox } from "../gen/box-protocol.js";
|
||||
import { fromObserve, Observe } from "../gen/dataspace.js";
|
||||
import { $BoxState, fromSetBox, SetBox } from "../gen/examples/boxProtocol.js";
|
||||
import { fromObserve, Observe, P } from "../runtime/dataspace.js";
|
||||
import { Assertion, Ref, Turn } from "../runtime/actor.js";
|
||||
|
||||
export default function (t: Turn, ds_p: Embedded<Ref>) {
|
||||
|
|
@ -8,7 +8,7 @@ export default function (t: Turn, ds_p: Embedded<Ref>) {
|
|||
console.log('Spawning Client');
|
||||
let count = 0;
|
||||
t.assert(ds, fromObserve(Observe({
|
||||
label: $BoxState,
|
||||
pattern: P.rec($BoxState, P.bind('currentValue', P.discard())),
|
||||
observer: t.ref({
|
||||
assert(t: Turn, [currentValue]: [number]): void {
|
||||
// console.log(`Client ${t.actor.id}: got ${currentValue}`);
|
||||
|
|
@ -17,7 +17,7 @@ export default function (t: Turn, ds_p: Embedded<Ref>) {
|
|||
})
|
||||
})));
|
||||
t.assert(ds, fromObserve(Observe({
|
||||
label: $BoxState,
|
||||
pattern: P.rec($BoxState, P.discard()),
|
||||
observer: t.ref({
|
||||
assert(_t: Turn, _assertion: Assertion): void {
|
||||
count++;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ import { Actor, Assertion, Turn } from '../runtime/actor.js';
|
|||
import { Dictionary, embed } from '@preserves/core';
|
||||
import { Dataspace } from '../runtime/dataspace.js';
|
||||
import { _embedded, attenuate, CRec, Lit, Pattern, PCompound, rfilter, ConstructorSpec } from '../runtime/rewrite.js';
|
||||
import { $BoxState, $SetBox } from '../gen/box-protocol.js';
|
||||
import { $BoxState, $SetBox } from '../gen/examples/boxProtocol.js';
|
||||
import { $Observe } from '../gen/dataspace.js';
|
||||
import { spawnWorker } from '../worker/index.js';
|
||||
import path from 'path';
|
||||
|
|
|
|||
|
|
@ -1,16 +1,17 @@
|
|||
import { $joinedUser, $says, $user, asJoin, asSays, asUserInfo, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secure-chat-protocol.js";
|
||||
import { during, observe } from "../runtime/dataspace.js";
|
||||
import { $joinedUser, $says, $user, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secureChatProtocol.js";
|
||||
import { during, observe, P } from "../runtime/dataspace.js";
|
||||
import { Assertion, Ref, Turn } from "../runtime/actor.js";
|
||||
import { attachReadline } from './readline.js';
|
||||
import { Embedded } from "@preserves/core";
|
||||
|
||||
export default function (t: Turn, ds_ptr: Embedded<Ref>) {
|
||||
const ds = ds_ptr.embeddedValue;
|
||||
observe(t, ds, $joinedUser, during(async (t, j0) => {
|
||||
const j = asJoin(j0);
|
||||
const facet = t.facet(t => runSession(t, j.uid, j.handle));
|
||||
return t => t.stop(facet);
|
||||
}));
|
||||
observe(t, ds, P.rec($joinedUser, P.bind('uid', P.discard()), P.bind('handle', P.discard())),
|
||||
during(async (t, bindings) => {
|
||||
let [uid, handle] = bindings as [UserId, Ref];
|
||||
const facet = t.facet(t => runSession(t, uid, handle));
|
||||
return t => t.stop(facet);
|
||||
}));
|
||||
}
|
||||
|
||||
function runSession(t: Turn, uid: UserId, session: Ref) {
|
||||
|
|
@ -39,25 +40,26 @@ function runSession(t: Turn, uid: UserId, session: Ref) {
|
|||
updateUsername(t, 'user' + process.pid);
|
||||
|
||||
const users = new Map<UserId, string>();
|
||||
observe(t, session, $user, during(async (_t, ui0) => {
|
||||
const ui = asUserInfo(ui0);
|
||||
const oldName = users.get(ui.uid);
|
||||
console.log(oldName === void 0
|
||||
? `${ui.name} arrived`
|
||||
: `${oldName} changed name to ${ui.name}`);
|
||||
users.set(ui.uid, ui.name);
|
||||
return (_t) => {
|
||||
if (users.get(ui.uid) === ui.name) {
|
||||
console.log(`${ui.name} departed`);
|
||||
users.delete(ui.uid);
|
||||
}
|
||||
};
|
||||
}));
|
||||
observe(t, session, P.rec($user, P.bind('uid', P.discard()), P.bind('name', P.discard())),
|
||||
during(async (_t, bindings) => {
|
||||
let [uid, name] = bindings as [UserId, string];
|
||||
const oldName = users.get(uid);
|
||||
console.log(oldName === void 0
|
||||
? `${name} arrived`
|
||||
: `${oldName} changed name to ${name}`);
|
||||
users.set(uid, name);
|
||||
return (_t) => {
|
||||
if (users.get(uid) === name) {
|
||||
console.log(`${name} departed`);
|
||||
users.delete(uid);
|
||||
}
|
||||
};
|
||||
}));
|
||||
|
||||
observe(t, session, $says, {
|
||||
message(_t: Turn, u0: Assertion): void {
|
||||
const u = asSays(u0);
|
||||
console.log(`${users.get(u.who) ?? `<unknown ${u.who}>`}: ${u.what}`);
|
||||
observe(t, session, P.rec($says, P.bind('who', P.discard()), P.bind('what', P.discard())), {
|
||||
message(_t: Turn, bindings: Assertion): void {
|
||||
let [who, what] = bindings as [UserId, string];
|
||||
console.log(`${users.get(who) ?? `<unknown ${who}>`}: ${what}`);
|
||||
},
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -7,14 +7,13 @@ import {
|
|||
NickConflict,
|
||||
UserId,
|
||||
UserInfo,
|
||||
asNickClaim,
|
||||
fromJoin,
|
||||
fromNickConflict,
|
||||
fromUserInfo,
|
||||
} from "../gen/secure-chat-protocol.js";
|
||||
} from "../gen/secureChatProtocol.js";
|
||||
import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
|
||||
import { observe, during, $Observe, asObserve, Dataspace } from "../runtime/dataspace.js";
|
||||
import { attenuate, rfilter, pRec, pEmbedded, pString, pLit } from "../runtime/rewrite.js";
|
||||
import { observe, during, $Observe, Dataspace, P, $rec, $compound } from "../runtime/dataspace.js";
|
||||
import { attenuate, rfilter, pRec, pEmbedded, pString, pLit, pDiscard } from "../runtime/rewrite.js";
|
||||
import { attenuate as sturdyAttenuate, KEY_LENGTH, sturdyEncode, fromSturdyRef, mint } from "../transport/sturdy.js";
|
||||
import { Bind, fromBind } from "../gen/gatekeeper.js";
|
||||
import { Bytes, Embedded } from "@preserves/core";
|
||||
|
|
@ -28,7 +27,11 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded<Ref>) {
|
|||
const chatKey = new Bytes(KEY_LENGTH);
|
||||
t.assert(gatekeeperDs, fromBind(Bind({ oid: chatOid, key: chatKey, target: ds })));
|
||||
mint(chatOid, chatKey).then(async r => {
|
||||
r = await sturdyAttenuate(r, rfilter(pRec($Observe, pLit($joinedUser), pEmbedded())));
|
||||
r = await sturdyAttenuate(r, rfilter(pRec($Observe,
|
||||
pRec($compound,
|
||||
pRec($rec, pLit($joinedUser), pLit(2)),
|
||||
pDiscard()),
|
||||
pEmbedded())));
|
||||
console.log(fromSturdyRef(r).asPreservesText());
|
||||
console.log(sturdyEncode(fromSturdyRef(r)).toHex());
|
||||
});
|
||||
|
|
@ -36,39 +39,45 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded<Ref>) {
|
|||
const nicks = new Map<string, UserId>();
|
||||
|
||||
let nextUserId: UserId = 0;
|
||||
observe(t, ds, $Observe, during(async (t, o0) => {
|
||||
const o = asObserve(o0);
|
||||
if (o.label !== $joinedUser) return null;
|
||||
observe(t, ds, P.rec($Observe,
|
||||
P.rec($compound,
|
||||
P.rec($rec, P.lit($joinedUser), P.lit(2)),
|
||||
P.discard()),
|
||||
P.bind('observer', P.discard())),
|
||||
during(async (t, bindings) => {
|
||||
const [embeddedObserver] = bindings as [Embedded<Ref>];
|
||||
const observer = embeddedObserver.embeddedValue;
|
||||
|
||||
const uid: UserId = nextUserId++;
|
||||
const f = t.facet(t => {
|
||||
t.assert(o.observer, fromJoin(Join({
|
||||
uid,
|
||||
handle: attenuate(ds, rfilter(
|
||||
pRec($Observe, pLit($user), pEmbedded()),
|
||||
pRec($Observe, pLit($says), pEmbedded()),
|
||||
pRec($claimNick, pLit(uid), pString(), pEmbedded()),
|
||||
pRec($says, pLit(uid), pString()))),
|
||||
})));
|
||||
let infoHandle: Handle | undefined;
|
||||
let nick: string | undefined;
|
||||
observe(t, ds, $claimNick, {
|
||||
assert(t: Turn, c0: Assertion): void {
|
||||
const c = asNickClaim(c0);
|
||||
if (c.uid !== uid) return;
|
||||
if (nicks.has(c.name)) {
|
||||
t.message(c.k, fromNickConflict(NickConflict()));
|
||||
} else {
|
||||
t.message(c.k, true);
|
||||
if (nick !== void 0) nicks.delete(nick);
|
||||
infoHandle = t.replace(ds, infoHandle, fromUserInfo(UserInfo(c)));
|
||||
nick = c.name;
|
||||
nicks.set(nick, uid);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
const uid: UserId = nextUserId++;
|
||||
const f = t.facet(t => {
|
||||
t.assert(observer, fromJoin(Join({
|
||||
uid,
|
||||
handle: attenuate(ds, rfilter(
|
||||
pRec($Observe, pLit($user), pEmbedded()),
|
||||
pRec($Observe, pLit($says), pEmbedded()),
|
||||
pRec($claimNick, pLit(uid), pString(), pEmbedded()),
|
||||
pRec($says, pLit(uid), pString()))),
|
||||
})));
|
||||
let infoHandle: Handle | undefined;
|
||||
let nick: string | undefined;
|
||||
observe(t, ds, P.rec($claimNick, P.lit(uid), P.bind('name'), P.bind('k')), {
|
||||
assert(t: Turn, bindings: Assertion): void {
|
||||
const [name, embeddedK] = bindings as [string, Embedded<Ref>];
|
||||
const k = embeddedK.embeddedValue;
|
||||
if (nicks.has(name)) {
|
||||
t.message(k, fromNickConflict(NickConflict()));
|
||||
} else {
|
||||
t.message(k, true);
|
||||
if (nick !== void 0) nicks.delete(nick);
|
||||
infoHandle = t.replace(ds, infoHandle,
|
||||
fromUserInfo(UserInfo({ uid, name })));
|
||||
nick = name;
|
||||
nicks.set(nick, uid);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
return t => t.stop(f);
|
||||
}));
|
||||
return t => t.stop(f);
|
||||
}));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
import { $Present, $Says, asPresent, asSays, fromPresent, fromSays, Present, Says } from "../gen/simple-chat-protocol.js";
|
||||
import { during, observe } from "../runtime/dataspace.js";
|
||||
import { $Present, $Says, fromPresent, fromSays, Present, Says } from "../gen/simpleChatProtocol.js";
|
||||
import { during, observe, P } from "../runtime/dataspace.js";
|
||||
import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
|
||||
import { attachReadline } from './readline.js';
|
||||
import { Embedded } from "@preserves/core";
|
||||
|
|
@ -16,16 +16,16 @@ export default function (t: Turn, ds_ptr: Embedded<Ref>) {
|
|||
}
|
||||
updateUsername(t, 'user' + process.pid);
|
||||
|
||||
observe(t, ds, $Present, during(async (_t, e0) => {
|
||||
const e = asPresent(e0);
|
||||
console.log(`${e.username} arrived`);
|
||||
return (_t) => console.log(`${e.username} departed`);
|
||||
observe(t, ds, P.rec($Present, P.bind('username')), during(async (_t, bindings) => {
|
||||
const [username] = bindings as [string];
|
||||
console.log(`${username} arrived`);
|
||||
return (_t) => console.log(`${username} departed`);
|
||||
}));
|
||||
|
||||
observe(t, ds, $Says, {
|
||||
message(_t: Turn, u0: Assertion): void {
|
||||
const u = asSays(u0);
|
||||
console.log(`${u.who}: ${u.what}`);
|
||||
observe(t, ds, P.rec($Says, P.bind('who'), P.bind('what')), {
|
||||
message(_t: Turn, bindings: Assertion): void {
|
||||
const [who, what] = bindings as [string, string];
|
||||
console.log(`${who}: ${what}`);
|
||||
},
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -1,40 +1,49 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
import * as _i_dataspacePatterns from "./dataspacePatterns";
|
||||
|
||||
export const $Observe = Symbol.for("Observe");
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
|
||||
export type Observe = {"label": symbol, "observer": _embedded};
|
||||
export type Observe<_embedded = _i_EntityRef.Ref> = {"pattern": _i_dataspacePatterns.Pattern<_embedded>, "observer": _embedded};
|
||||
|
||||
|
||||
export function Observe({label, observer}: {label: symbol, observer: _embedded}): Observe {return {"label": label, "observer": observer};}
|
||||
export function Observe<_embedded = _i_EntityRef.Ref>(
|
||||
{pattern, observer}: {pattern: _i_dataspacePatterns.Pattern<_embedded>, observer: _embedded}
|
||||
): Observe<_embedded> {return {"pattern": pattern, "observer": observer};}
|
||||
|
||||
export function asObserve(v: _val): Observe {
|
||||
export function asObserve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Observe<_embedded> {
|
||||
let result = toObserve(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Observe: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toObserve(v: _val): undefined | Observe {
|
||||
let result: undefined | Observe;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toObserve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Observe<_embedded> {
|
||||
let result: undefined | Observe<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $Observe) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (symbol) | undefined;
|
||||
_tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0;
|
||||
let _tmp1: (_i_dataspacePatterns.Pattern<_embedded>) | undefined;
|
||||
_tmp1 = _i_dataspacePatterns.toPattern(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (_embedded) | undefined;
|
||||
_tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"label": _tmp1, "observer": _tmp2};};
|
||||
if (_tmp2 !== void 0) {result = {"pattern": _tmp1, "observer": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromObserve(_v: Observe): _val {return _.Record($Observe, [_v["label"], _.embed(_v["observer"])]);}
|
||||
export function fromObserve<_embedded = _i_EntityRef.Ref>(_v: Observe<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
$Observe,
|
||||
[
|
||||
_i_dataspacePatterns.fromPattern<_embedded>(_v["pattern"]),
|
||||
_.embed(_v["observer"])
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,392 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const $_ = Symbol.for("_");
|
||||
export const $arr = Symbol.for("arr");
|
||||
export const $bind = Symbol.for("bind");
|
||||
export const $compound = Symbol.for("compound");
|
||||
export const $dict = Symbol.for("dict");
|
||||
export const $lit = Symbol.for("lit");
|
||||
export const $rec = Symbol.for("rec");
|
||||
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type Pattern<_embedded = _i_EntityRef.Ref> = (
|
||||
{"_variant": "DDiscard", "value": DDiscard} |
|
||||
{"_variant": "DBind", "value": DBind<_embedded>} |
|
||||
{"_variant": "DLit", "value": DLit<_embedded>} |
|
||||
{"_variant": "DCompound", "value": DCompound<_embedded>}
|
||||
);
|
||||
|
||||
export type DDiscard = null;
|
||||
|
||||
export type DBind<_embedded = _i_EntityRef.Ref> = {"name": symbol, "pattern": Pattern<_embedded>};
|
||||
|
||||
export type DLit<_embedded = _i_EntityRef.Ref> = {"value": _.Value<_embedded>};
|
||||
|
||||
export type DCompound<_embedded = _i_EntityRef.Ref> = (
|
||||
{
|
||||
"_variant": "rec",
|
||||
"ctor": CRec<_embedded>,
|
||||
"members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
||||
} |
|
||||
{
|
||||
"_variant": "arr",
|
||||
"ctor": CArr,
|
||||
"members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
||||
} |
|
||||
{
|
||||
"_variant": "dict",
|
||||
"ctor": CDict,
|
||||
"members": _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
|
||||
}
|
||||
);
|
||||
|
||||
export type CRec<_embedded = _i_EntityRef.Ref> = {"label": _.Value<_embedded>, "arity": number};
|
||||
|
||||
export type CArr = {"arity": number};
|
||||
|
||||
export type CDict = null;
|
||||
|
||||
|
||||
export namespace Pattern {
|
||||
export function DDiscard<_embedded = _i_EntityRef.Ref>(value: DDiscard): Pattern<_embedded> {return {"_variant": "DDiscard", "value": value};};
|
||||
export function DBind<_embedded = _i_EntityRef.Ref>(value: DBind<_embedded>): Pattern<_embedded> {return {"_variant": "DBind", "value": value};};
|
||||
export function DLit<_embedded = _i_EntityRef.Ref>(value: DLit<_embedded>): Pattern<_embedded> {return {"_variant": "DLit", "value": value};};
|
||||
export function DCompound<_embedded = _i_EntityRef.Ref>(value: DCompound<_embedded>): Pattern<_embedded> {return {"_variant": "DCompound", "value": value};};
|
||||
}
|
||||
|
||||
export function DDiscard(): DDiscard {return null;}
|
||||
|
||||
export function DBind<_embedded = _i_EntityRef.Ref>({name, pattern}: {name: symbol, pattern: Pattern<_embedded>}): DBind<_embedded> {return {"name": name, "pattern": pattern};}
|
||||
|
||||
export function DLit<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): DLit<_embedded> {return {"value": value};}
|
||||
|
||||
export namespace DCompound {
|
||||
export function rec<_embedded = _i_EntityRef.Ref>(
|
||||
{ctor, members}: {
|
||||
ctor: CRec<_embedded>,
|
||||
members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
||||
}
|
||||
): DCompound<_embedded> {return {"_variant": "rec", "ctor": ctor, "members": members};};
|
||||
export function arr<_embedded = _i_EntityRef.Ref>(
|
||||
{ctor, members}: {ctor: CArr, members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>}
|
||||
): DCompound<_embedded> {return {"_variant": "arr", "ctor": ctor, "members": members};};
|
||||
export function dict<_embedded = _i_EntityRef.Ref>(
|
||||
{ctor, members}: {
|
||||
ctor: CDict,
|
||||
members: _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
|
||||
}
|
||||
): DCompound<_embedded> {return {"_variant": "dict", "ctor": ctor, "members": members};};
|
||||
}
|
||||
|
||||
export function CRec<_embedded = _i_EntityRef.Ref>({label, arity}: {label: _.Value<_embedded>, arity: number}): CRec<_embedded> {return {"label": label, "arity": arity};}
|
||||
|
||||
export function CArr(arity: number): CArr {return {"arity": arity};}
|
||||
|
||||
export function CDict(): CDict {return null;}
|
||||
|
||||
export function asPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Pattern<_embedded> {
|
||||
let result = toPattern(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Pattern<_embedded> {
|
||||
let _tmp0: (DDiscard) | undefined;
|
||||
let result: undefined | Pattern<_embedded>;
|
||||
_tmp0 = toDDiscard(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "DDiscard", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (DBind<_embedded>) | undefined;
|
||||
_tmp1 = toDBind(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "DBind", "value": _tmp1};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (DLit<_embedded>) | undefined;
|
||||
_tmp2 = toDLit(v);
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "DLit", "value": _tmp2};};
|
||||
if (result === void 0) {
|
||||
let _tmp3: (DCompound<_embedded>) | undefined;
|
||||
_tmp3 = toDCompound(v);
|
||||
if (_tmp3 !== void 0) {result = {"_variant": "DCompound", "value": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromPattern<_embedded = _i_EntityRef.Ref>(_v: Pattern<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "DDiscard": {return fromDDiscard<_embedded>(_v.value);};
|
||||
case "DBind": {return fromDBind<_embedded>(_v.value);};
|
||||
case "DLit": {return fromDLit<_embedded>(_v.value);};
|
||||
case "DCompound": {return fromDCompound<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DDiscard {
|
||||
let result = toDDiscard(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid DDiscard: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DDiscard {
|
||||
let result: undefined | DDiscard;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $_) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {result = null;};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromDDiscard<_embedded = _i_EntityRef.Ref>(_v: DDiscard): _.Value<_embedded> {return _.Record($_, []);}
|
||||
|
||||
export function asDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DBind<_embedded> {
|
||||
let result = toDBind(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid DBind: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DBind<_embedded> {
|
||||
let result: undefined | DBind<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $bind) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (symbol) | undefined;
|
||||
_tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0;
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (Pattern<_embedded>) | undefined;
|
||||
_tmp2 = toPattern(v[1]);
|
||||
if (_tmp2 !== void 0) {result = {"name": _tmp1, "pattern": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromDBind<_embedded = _i_EntityRef.Ref>(_v: DBind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["name"], fromPattern<_embedded>(_v["pattern"])]);}
|
||||
|
||||
export function asDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DLit<_embedded> {
|
||||
let result = toDLit(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid DLit: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DLit<_embedded> {
|
||||
let result: undefined | DLit<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $lit) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (_.Value<_embedded>) | undefined;
|
||||
_tmp1 = v[0];
|
||||
if (_tmp1 !== void 0) {result = {"value": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromDLit<_embedded = _i_EntityRef.Ref>(_v: DLit<_embedded>): _.Value<_embedded> {return _.Record($lit, [_v["value"]]);}
|
||||
|
||||
export function asDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DCompound<_embedded> {
|
||||
let result = toDCompound(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid DCompound: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DCompound<_embedded> {
|
||||
let result: undefined | DCompound<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $compound) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (CRec<_embedded>) | undefined;
|
||||
_tmp1 = toCRec(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
|
||||
_tmp2 = void 0;
|
||||
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
||||
_tmp2 = new _.KeyedDictionary();
|
||||
for (const [_tmp4, _tmp3] of v[1]) {
|
||||
let _tmp5: (number) | undefined;
|
||||
_tmp5 = typeof _tmp4 === 'number' ? _tmp4 : void 0;
|
||||
if (_tmp5 !== void 0) {
|
||||
let _tmp6: (Pattern<_embedded>) | undefined;
|
||||
_tmp6 = toPattern(_tmp3);
|
||||
if (_tmp6 !== void 0) {_tmp2.set(_tmp5, _tmp6); continue;};
|
||||
};
|
||||
_tmp2 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "rec", "ctor": _tmp1, "members": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
if (result === void 0) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp7: (null) | undefined;
|
||||
_tmp7 = _.is(v.label, $compound) ? null : void 0;
|
||||
if (_tmp7 !== void 0) {
|
||||
let _tmp8: (CArr) | undefined;
|
||||
_tmp8 = toCArr(v[0]);
|
||||
if (_tmp8 !== void 0) {
|
||||
let _tmp9: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
|
||||
_tmp9 = void 0;
|
||||
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
||||
_tmp9 = new _.KeyedDictionary();
|
||||
for (const [_tmp11, _tmp10] of v[1]) {
|
||||
let _tmp12: (number) | undefined;
|
||||
_tmp12 = typeof _tmp11 === 'number' ? _tmp11 : void 0;
|
||||
if (_tmp12 !== void 0) {
|
||||
let _tmp13: (Pattern<_embedded>) | undefined;
|
||||
_tmp13 = toPattern(_tmp10);
|
||||
if (_tmp13 !== void 0) {_tmp9.set(_tmp12, _tmp13); continue;};
|
||||
};
|
||||
_tmp9 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp9 !== void 0) {result = {"_variant": "arr", "ctor": _tmp8, "members": _tmp9};};
|
||||
};
|
||||
};
|
||||
};
|
||||
if (result === void 0) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp14: (null) | undefined;
|
||||
_tmp14 = _.is(v.label, $compound) ? null : void 0;
|
||||
if (_tmp14 !== void 0) {
|
||||
let _tmp15: (CDict) | undefined;
|
||||
_tmp15 = toCDict(v[0]);
|
||||
if (_tmp15 !== void 0) {
|
||||
let _tmp16: (_.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>) | undefined;
|
||||
_tmp16 = void 0;
|
||||
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
||||
_tmp16 = new _.KeyedDictionary();
|
||||
for (const [_tmp18, _tmp17] of v[1]) {
|
||||
let _tmp19: (_.Value<_embedded>) | undefined;
|
||||
_tmp19 = _tmp18;
|
||||
if (_tmp19 !== void 0) {
|
||||
let _tmp20: (Pattern<_embedded>) | undefined;
|
||||
_tmp20 = toPattern(_tmp17);
|
||||
if (_tmp20 !== void 0) {_tmp16.set(_tmp19, _tmp20); continue;};
|
||||
};
|
||||
_tmp16 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp16 !== void 0) {result = {"_variant": "dict", "ctor": _tmp15, "members": _tmp16};};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromDCompound<_embedded = _i_EntityRef.Ref>(_v: DCompound<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "rec": {
|
||||
return _.Record(
|
||||
$compound,
|
||||
[
|
||||
fromCRec<_embedded>(_v["ctor"]),
|
||||
new _.Dictionary<_embedded>(
|
||||
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
||||
)
|
||||
]
|
||||
);
|
||||
};
|
||||
case "arr": {
|
||||
return _.Record(
|
||||
$compound,
|
||||
[
|
||||
fromCArr<_embedded>(_v["ctor"]),
|
||||
new _.Dictionary<_embedded>(
|
||||
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
||||
)
|
||||
]
|
||||
);
|
||||
};
|
||||
case "dict": {
|
||||
return _.Record(
|
||||
$compound,
|
||||
[
|
||||
fromCDict<_embedded>(_v["ctor"]),
|
||||
new _.Dictionary<_embedded>(
|
||||
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
||||
)
|
||||
]
|
||||
);
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
export function asCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CRec<_embedded> {
|
||||
let result = toCRec(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid CRec: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CRec<_embedded> {
|
||||
let result: undefined | CRec<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $rec) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (_.Value<_embedded>) | undefined;
|
||||
_tmp1 = v[0];
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (number) | undefined;
|
||||
_tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"label": _tmp1, "arity": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromCRec<_embedded = _i_EntityRef.Ref>(_v: CRec<_embedded>): _.Value<_embedded> {return _.Record($rec, [_v["label"], _v["arity"]]);}
|
||||
|
||||
export function asCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CArr {
|
||||
let result = toCArr(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid CArr: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CArr {
|
||||
let result: undefined | CArr;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $arr) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (number) | undefined;
|
||||
_tmp1 = typeof v[0] === 'number' ? v[0] : void 0;
|
||||
if (_tmp1 !== void 0) {result = {"arity": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromCArr<_embedded = _i_EntityRef.Ref>(_v: CArr): _.Value<_embedded> {return _.Record($arr, [_v["arity"]]);}
|
||||
|
||||
export function asCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CDict {
|
||||
let result = toCDict(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid CDict: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CDict {
|
||||
let result: undefined | CDict;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $dict) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {result = null;};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromCDict<_embedded = _i_EntityRef.Ref>(_v: CDict): _.Value<_embedded> {return _.Record($dict, []);}
|
||||
|
||||
|
|
@ -1,12 +1,10 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../../runtime/actor";
|
||||
|
||||
export const $BoxState = Symbol.for("BoxState");
|
||||
export const $SetBox = Symbol.for("SetBox");
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type BoxState = {"value": number};
|
||||
|
||||
|
|
@ -17,15 +15,15 @@ export function BoxState(value: number): BoxState {return {"value": value};}
|
|||
|
||||
export function SetBox(value: number): SetBox {return {"value": value};}
|
||||
|
||||
export function asBoxState(v: _val): BoxState {
|
||||
export function asBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): BoxState {
|
||||
let result = toBoxState(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid BoxState: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toBoxState(v: _val): undefined | BoxState {
|
||||
export function toBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | BoxState {
|
||||
let result: undefined | BoxState;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $BoxState) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -37,17 +35,17 @@ export function toBoxState(v: _val): undefined | BoxState {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromBoxState(_v: BoxState): _val {return _.Record($BoxState, [_v["value"]]);}
|
||||
export function fromBoxState<_embedded = _i_EntityRef.Ref>(_v: BoxState): _.Value<_embedded> {return _.Record($BoxState, [_v["value"]]);}
|
||||
|
||||
export function asSetBox(v: _val): SetBox {
|
||||
export function asSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): SetBox {
|
||||
let result = toSetBox(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid SetBox: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSetBox(v: _val): undefined | SetBox {
|
||||
export function toSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | SetBox {
|
||||
let result: undefined | SetBox;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $SetBox) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -59,5 +57,5 @@ export function toSetBox(v: _val): undefined | SetBox {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromSetBox(_v: SetBox): _val {return _.Record($SetBox, [_v["value"]]);}
|
||||
export function fromSetBox<_embedded = _i_EntityRef.Ref>(_v: SetBox): _.Value<_embedded> {return _.Record($SetBox, [_v["value"]]);}
|
||||
|
||||
|
|
@ -0,0 +1,359 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_sturdy from "./sturdy";
|
||||
|
||||
export const $assert = Symbol.for("assert");
|
||||
export const $error = Symbol.for("error");
|
||||
export const $message = Symbol.for("message");
|
||||
export const $retract = Symbol.for("retract");
|
||||
export const $sync = Symbol.for("sync");
|
||||
|
||||
export type _embedded = _i_sturdy.WireRef;
|
||||
|
||||
export type Packet<_embedded = _i_sturdy.WireRef> = (
|
||||
{"_variant": "Turn", "value": Turn<_embedded>} |
|
||||
{"_variant": "Error", "value": Error<_embedded>}
|
||||
);
|
||||
|
||||
export type Error<_embedded = _i_sturdy.WireRef> = {"message": string, "detail": _.Value<_embedded>};
|
||||
|
||||
export type Assertion<_embedded = _i_sturdy.WireRef> = _.Value<_embedded>;
|
||||
|
||||
export type Handle = number;
|
||||
|
||||
export type Event<_embedded = _i_sturdy.WireRef> = (
|
||||
{"_variant": "Assert", "value": Assert<_embedded>} |
|
||||
{"_variant": "Retract", "value": Retract} |
|
||||
{"_variant": "Message", "value": Message<_embedded>} |
|
||||
{"_variant": "Sync", "value": Sync<_embedded>}
|
||||
);
|
||||
|
||||
export type Oid = number;
|
||||
|
||||
export type Turn<_embedded = _i_sturdy.WireRef> = Array<TurnEvent<_embedded>>;
|
||||
|
||||
export type TurnEvent<_embedded = _i_sturdy.WireRef> = {"oid": Oid, "event": Event<_embedded>};
|
||||
|
||||
export type Assert<_embedded = _i_sturdy.WireRef> = {"assertion": Assertion<_embedded>, "handle": Handle};
|
||||
|
||||
export type Retract = {"handle": Handle};
|
||||
|
||||
export type Message<_embedded = _i_sturdy.WireRef> = {"body": Assertion<_embedded>};
|
||||
|
||||
export type Sync<_embedded = _i_sturdy.WireRef> = {"peer": _embedded};
|
||||
|
||||
|
||||
export namespace Packet {
|
||||
export function Turn<_embedded = _i_sturdy.WireRef>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};};
|
||||
export function Error<_embedded = _i_sturdy.WireRef>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};};
|
||||
}
|
||||
|
||||
export function Error<_embedded = _i_sturdy.WireRef>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};}
|
||||
|
||||
export function Assertion<_embedded = _i_sturdy.WireRef>(value: _.Value<_embedded>): Assertion<_embedded> {return value;}
|
||||
|
||||
export function Handle(value: number): Handle {return value;}
|
||||
|
||||
export namespace Event {
|
||||
export function Assert<_embedded = _i_sturdy.WireRef>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};};
|
||||
export function Retract<_embedded = _i_sturdy.WireRef>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};};
|
||||
export function Message<_embedded = _i_sturdy.WireRef>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};};
|
||||
export function Sync<_embedded = _i_sturdy.WireRef>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};};
|
||||
}
|
||||
|
||||
export function Oid(value: number): Oid {return value;}
|
||||
|
||||
export function Turn<_embedded = _i_sturdy.WireRef>(value: Array<TurnEvent<_embedded>>): Turn<_embedded> {return value;}
|
||||
|
||||
export function TurnEvent<_embedded = _i_sturdy.WireRef>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};}
|
||||
|
||||
export function Assert<_embedded = _i_sturdy.WireRef>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};}
|
||||
|
||||
export function Retract(handle: Handle): Retract {return {"handle": handle};}
|
||||
|
||||
export function Message<_embedded = _i_sturdy.WireRef>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};}
|
||||
|
||||
export function Sync<_embedded = _i_sturdy.WireRef>(peer: _embedded): Sync<_embedded> {return {"peer": peer};}
|
||||
|
||||
export function asPacket<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Packet<_embedded> {
|
||||
let result = toPacket(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toPacket<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Packet<_embedded> {
|
||||
let _tmp0: (Turn<_embedded>) | undefined;
|
||||
let result: undefined | Packet<_embedded>;
|
||||
_tmp0 = toTurn(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Error<_embedded>) | undefined;
|
||||
_tmp1 = toError(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromPacket<_embedded = _i_sturdy.WireRef>(_v: Packet<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Turn": {return fromTurn<_embedded>(_v.value);};
|
||||
case "Error": {return fromError<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asError<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Error<_embedded> {
|
||||
let result = toError(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toError<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Error<_embedded> {
|
||||
let result: undefined | Error<_embedded>;
|
||||
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) {
|
||||
let _tmp2: (_.Value<_embedded>) | undefined;
|
||||
_tmp2 = v[1];
|
||||
if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromError<_embedded = _i_sturdy.WireRef>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);}
|
||||
|
||||
export function asAssertion<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Assertion<_embedded> {
|
||||
let result = toAssertion(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssertion<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Assertion<_embedded> {
|
||||
let _tmp0: (_.Value<_embedded>) | undefined;
|
||||
let result: undefined | Assertion<_embedded>;
|
||||
_tmp0 = v;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssertion<_embedded = _i_sturdy.WireRef>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asHandle<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Handle {
|
||||
let result = toHandle(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toHandle<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Handle {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Handle;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromHandle<_embedded = _i_sturdy.WireRef>(_v: Handle): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Event<_embedded> {
|
||||
let result = toEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Event<_embedded> {
|
||||
let _tmp0: (Assert<_embedded>) | undefined;
|
||||
let result: undefined | Event<_embedded>;
|
||||
_tmp0 = toAssert(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Retract) | undefined;
|
||||
_tmp1 = toRetract(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (Message<_embedded>) | undefined;
|
||||
_tmp2 = toMessage(v);
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
|
||||
if (result === void 0) {
|
||||
let _tmp3: (Sync<_embedded>) | undefined;
|
||||
_tmp3 = toSync(v);
|
||||
if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromEvent<_embedded = _i_sturdy.WireRef>(_v: Event<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Assert": {return fromAssert<_embedded>(_v.value);};
|
||||
case "Retract": {return fromRetract<_embedded>(_v.value);};
|
||||
case "Message": {return fromMessage<_embedded>(_v.value);};
|
||||
case "Sync": {return fromSync<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asOid<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Oid {
|
||||
let result = toOid(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toOid<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Oid {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Oid;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromOid<_embedded = _i_sturdy.WireRef>(_v: Oid): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asTurn<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Turn<_embedded> {
|
||||
let result = toTurn(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurn<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Turn<_embedded> {
|
||||
let _tmp0: (Array<TurnEvent<_embedded>>) | undefined;
|
||||
let result: undefined | Turn<_embedded>;
|
||||
_tmp0 = void 0;
|
||||
if (_.Array.isArray(v)) {
|
||||
_tmp0 = [];
|
||||
for (const _tmp1 of v) {
|
||||
let _tmp2: (TurnEvent<_embedded>) | undefined;
|
||||
_tmp2 = toTurnEvent(_tmp1);
|
||||
if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
|
||||
_tmp0 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurn<_embedded = _i_sturdy.WireRef>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));}
|
||||
|
||||
export function asTurnEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): TurnEvent<_embedded> {
|
||||
let result = toTurnEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurnEvent<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> {
|
||||
let result: undefined | TurnEvent<_embedded>;
|
||||
if (_.Array.isArray(v) && v.length === 2) {
|
||||
let _tmp0: (Oid) | undefined;
|
||||
_tmp0 = toOid(v[0]);
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Event<_embedded>) | undefined;
|
||||
_tmp1 = toEvent(v[1]);
|
||||
if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurnEvent<_embedded = _i_sturdy.WireRef>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];}
|
||||
|
||||
export function asAssert<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Assert<_embedded> {
|
||||
let result = toAssert(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssert<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Assert<_embedded> {
|
||||
let result: undefined | Assert<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $assert) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (Handle) | undefined;
|
||||
_tmp2 = toHandle(v[1]);
|
||||
if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssert<_embedded = _i_sturdy.WireRef>(_v: Assert<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
$assert,
|
||||
[fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])]
|
||||
);
|
||||
}
|
||||
|
||||
export function asRetract<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Retract {
|
||||
let result = toRetract(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRetract<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Retract {
|
||||
let result: undefined | Retract;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $retract) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Handle) | undefined;
|
||||
_tmp1 = toHandle(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRetract<_embedded = _i_sturdy.WireRef>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);}
|
||||
|
||||
export function asMessage<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Message<_embedded> {
|
||||
let result = toMessage(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toMessage<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Message<_embedded> {
|
||||
let result: undefined | Message<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $message) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"body": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromMessage<_embedded = _i_sturdy.WireRef>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);}
|
||||
|
||||
export function asSync<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): Sync<_embedded> {
|
||||
let result = toSync(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSync<_embedded = _i_sturdy.WireRef>(v: _.Value<_embedded>): undefined | Sync<_embedded> {
|
||||
let result: undefined | Sync<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $sync) ? 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 = {"peer": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromSync<_embedded = _i_sturdy.WireRef>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);}
|
||||
|
||||
|
|
@ -1,36 +1,36 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
import * as _i_sturdy from "./sturdy";
|
||||
|
||||
export const $bind = Symbol.for("bind");
|
||||
export const $resolve = Symbol.for("resolve");
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
export type Resolve<_embedded = _i_EntityRef.Ref> = {"sturdyref": _i_sturdy.SturdyRef<_embedded>, "observer": _embedded};
|
||||
|
||||
export type Resolve = {"sturdyref": _i_sturdy.SturdyRef, "observer": _embedded};
|
||||
|
||||
export type Bind = {"oid": _val, "key": _.Bytes, "target": _embedded};
|
||||
export type Bind<_embedded = _i_EntityRef.Ref> = {"oid": _.Value<_embedded>, "key": _.Bytes, "target": _embedded};
|
||||
|
||||
|
||||
export function Resolve({sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef, observer: _embedded}): Resolve {return {"sturdyref": sturdyref, "observer": observer};}
|
||||
export function Resolve<_embedded = _i_EntityRef.Ref>(
|
||||
{sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef<_embedded>, observer: _embedded}
|
||||
): Resolve<_embedded> {return {"sturdyref": sturdyref, "observer": observer};}
|
||||
|
||||
export function Bind({oid, key, target}: {oid: _val, key: _.Bytes, target: _embedded}): Bind {return {"oid": oid, "key": key, "target": target};}
|
||||
export function Bind<_embedded = _i_EntityRef.Ref>({oid, key, target}: {oid: _.Value<_embedded>, key: _.Bytes, target: _embedded}): Bind<_embedded> {return {"oid": oid, "key": key, "target": target};}
|
||||
|
||||
export function asResolve(v: _val): Resolve {
|
||||
export function asResolve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Resolve<_embedded> {
|
||||
let result = toResolve(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Resolve: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toResolve(v: _val): undefined | Resolve {
|
||||
let result: undefined | Resolve;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toResolve<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Resolve<_embedded> {
|
||||
let result: undefined | Resolve<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $resolve) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (_i_sturdy.SturdyRef) | undefined;
|
||||
let _tmp1: (_i_sturdy.SturdyRef<_embedded>) | undefined;
|
||||
_tmp1 = _i_sturdy.toSturdyRef(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (_embedded) | undefined;
|
||||
|
|
@ -42,23 +42,26 @@ export function toResolve(v: _val): undefined | Resolve {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromResolve(_v: Resolve): _val {
|
||||
return _.Record($resolve, [_i_sturdy.fromSturdyRef(_v["sturdyref"]), _.embed(_v["observer"])]);
|
||||
export function fromResolve<_embedded = _i_EntityRef.Ref>(_v: Resolve<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
$resolve,
|
||||
[_i_sturdy.fromSturdyRef<_embedded>(_v["sturdyref"]), _.embed(_v["observer"])]
|
||||
);
|
||||
}
|
||||
|
||||
export function asBind(v: _val): Bind {
|
||||
export function asBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Bind<_embedded> {
|
||||
let result = toBind(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Bind: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toBind(v: _val): undefined | Bind {
|
||||
let result: undefined | Bind;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Bind<_embedded> {
|
||||
let result: undefined | Bind<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $bind) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (_val) | undefined;
|
||||
let _tmp1: (_.Value<_embedded>) | undefined;
|
||||
_tmp1 = v[0];
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (_.Bytes) | undefined;
|
||||
|
|
@ -74,5 +77,5 @@ export function toBind(v: _val): undefined | Bind {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromBind(_v: Bind): _val {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);}
|
||||
export function fromBind<_embedded = _i_EntityRef.Ref>(_v: Bind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,356 @@
|
|||
import * as _ from "@preserves/core";
|
||||
|
||||
export const $assert = Symbol.for("assert");
|
||||
export const $error = Symbol.for("error");
|
||||
export const $message = Symbol.for("message");
|
||||
export const $retract = Symbol.for("retract");
|
||||
export const $sync = Symbol.for("sync");
|
||||
|
||||
export type Packet<_embedded = _.GenericEmbedded> = (
|
||||
{"_variant": "Turn", "value": Turn<_embedded>} |
|
||||
{"_variant": "Error", "value": Error<_embedded>}
|
||||
);
|
||||
|
||||
export type Error<_embedded = _.GenericEmbedded> = {"message": string, "detail": _.Value<_embedded>};
|
||||
|
||||
export type Assertion<_embedded = _.GenericEmbedded> = _.Value<_embedded>;
|
||||
|
||||
export type Handle = number;
|
||||
|
||||
export type Event<_embedded = _.GenericEmbedded> = (
|
||||
{"_variant": "Assert", "value": Assert<_embedded>} |
|
||||
{"_variant": "Retract", "value": Retract} |
|
||||
{"_variant": "Message", "value": Message<_embedded>} |
|
||||
{"_variant": "Sync", "value": Sync<_embedded>}
|
||||
);
|
||||
|
||||
export type Oid = number;
|
||||
|
||||
export type Turn<_embedded = _.GenericEmbedded> = Array<TurnEvent<_embedded>>;
|
||||
|
||||
export type TurnEvent<_embedded = _.GenericEmbedded> = {"oid": Oid, "event": Event<_embedded>};
|
||||
|
||||
export type Assert<_embedded = _.GenericEmbedded> = {"assertion": Assertion<_embedded>, "handle": Handle};
|
||||
|
||||
export type Retract = {"handle": Handle};
|
||||
|
||||
export type Message<_embedded = _.GenericEmbedded> = {"body": Assertion<_embedded>};
|
||||
|
||||
export type Sync<_embedded = _.GenericEmbedded> = {"peer": _embedded};
|
||||
|
||||
|
||||
export namespace Packet {
|
||||
export function Turn<_embedded = _.GenericEmbedded>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};};
|
||||
export function Error<_embedded = _.GenericEmbedded>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};};
|
||||
}
|
||||
|
||||
export function Error<_embedded = _.GenericEmbedded>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};}
|
||||
|
||||
export function Assertion<_embedded = _.GenericEmbedded>(value: _.Value<_embedded>): Assertion<_embedded> {return value;}
|
||||
|
||||
export function Handle(value: number): Handle {return value;}
|
||||
|
||||
export namespace Event {
|
||||
export function Assert<_embedded = _.GenericEmbedded>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};};
|
||||
export function Retract<_embedded = _.GenericEmbedded>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};};
|
||||
export function Message<_embedded = _.GenericEmbedded>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};};
|
||||
export function Sync<_embedded = _.GenericEmbedded>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};};
|
||||
}
|
||||
|
||||
export function Oid(value: number): Oid {return value;}
|
||||
|
||||
export function Turn<_embedded = _.GenericEmbedded>(value: Array<TurnEvent<_embedded>>): Turn<_embedded> {return value;}
|
||||
|
||||
export function TurnEvent<_embedded = _.GenericEmbedded>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};}
|
||||
|
||||
export function Assert<_embedded = _.GenericEmbedded>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};}
|
||||
|
||||
export function Retract(handle: Handle): Retract {return {"handle": handle};}
|
||||
|
||||
export function Message<_embedded = _.GenericEmbedded>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};}
|
||||
|
||||
export function Sync<_embedded = _.GenericEmbedded>(peer: _embedded): Sync<_embedded> {return {"peer": peer};}
|
||||
|
||||
export function asPacket<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Packet<_embedded> {
|
||||
let result = toPacket(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toPacket<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Packet<_embedded> {
|
||||
let _tmp0: (Turn<_embedded>) | undefined;
|
||||
let result: undefined | Packet<_embedded>;
|
||||
_tmp0 = toTurn(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Error<_embedded>) | undefined;
|
||||
_tmp1 = toError(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromPacket<_embedded = _.GenericEmbedded>(_v: Packet<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Turn": {return fromTurn<_embedded>(_v.value);};
|
||||
case "Error": {return fromError<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asError<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Error<_embedded> {
|
||||
let result = toError(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toError<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Error<_embedded> {
|
||||
let result: undefined | Error<_embedded>;
|
||||
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) {
|
||||
let _tmp2: (_.Value<_embedded>) | undefined;
|
||||
_tmp2 = v[1];
|
||||
if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromError<_embedded = _.GenericEmbedded>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);}
|
||||
|
||||
export function asAssertion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Assertion<_embedded> {
|
||||
let result = toAssertion(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssertion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Assertion<_embedded> {
|
||||
let _tmp0: (_.Value<_embedded>) | undefined;
|
||||
let result: undefined | Assertion<_embedded>;
|
||||
_tmp0 = v;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssertion<_embedded = _.GenericEmbedded>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asHandle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Handle {
|
||||
let result = toHandle(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toHandle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Handle {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Handle;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromHandle<_embedded = _.GenericEmbedded>(_v: Handle): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Event<_embedded> {
|
||||
let result = toEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Event<_embedded> {
|
||||
let _tmp0: (Assert<_embedded>) | undefined;
|
||||
let result: undefined | Event<_embedded>;
|
||||
_tmp0 = toAssert(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Retract) | undefined;
|
||||
_tmp1 = toRetract(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (Message<_embedded>) | undefined;
|
||||
_tmp2 = toMessage(v);
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
|
||||
if (result === void 0) {
|
||||
let _tmp3: (Sync<_embedded>) | undefined;
|
||||
_tmp3 = toSync(v);
|
||||
if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromEvent<_embedded = _.GenericEmbedded>(_v: Event<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Assert": {return fromAssert<_embedded>(_v.value);};
|
||||
case "Retract": {return fromRetract<_embedded>(_v.value);};
|
||||
case "Message": {return fromMessage<_embedded>(_v.value);};
|
||||
case "Sync": {return fromSync<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asOid<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Oid {
|
||||
let result = toOid(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toOid<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Oid {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Oid;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromOid<_embedded = _.GenericEmbedded>(_v: Oid): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asTurn<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Turn<_embedded> {
|
||||
let result = toTurn(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurn<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Turn<_embedded> {
|
||||
let _tmp0: (Array<TurnEvent<_embedded>>) | undefined;
|
||||
let result: undefined | Turn<_embedded>;
|
||||
_tmp0 = void 0;
|
||||
if (_.Array.isArray(v)) {
|
||||
_tmp0 = [];
|
||||
for (const _tmp1 of v) {
|
||||
let _tmp2: (TurnEvent<_embedded>) | undefined;
|
||||
_tmp2 = toTurnEvent(_tmp1);
|
||||
if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
|
||||
_tmp0 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurn<_embedded = _.GenericEmbedded>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));}
|
||||
|
||||
export function asTurnEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TurnEvent<_embedded> {
|
||||
let result = toTurnEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurnEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> {
|
||||
let result: undefined | TurnEvent<_embedded>;
|
||||
if (_.Array.isArray(v) && v.length === 2) {
|
||||
let _tmp0: (Oid) | undefined;
|
||||
_tmp0 = toOid(v[0]);
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Event<_embedded>) | undefined;
|
||||
_tmp1 = toEvent(v[1]);
|
||||
if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurnEvent<_embedded = _.GenericEmbedded>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];}
|
||||
|
||||
export function asAssert<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Assert<_embedded> {
|
||||
let result = toAssert(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssert<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Assert<_embedded> {
|
||||
let result: undefined | Assert<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $assert) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (Handle) | undefined;
|
||||
_tmp2 = toHandle(v[1]);
|
||||
if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssert<_embedded = _.GenericEmbedded>(_v: Assert<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
$assert,
|
||||
[fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])]
|
||||
);
|
||||
}
|
||||
|
||||
export function asRetract<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Retract {
|
||||
let result = toRetract(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRetract<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Retract {
|
||||
let result: undefined | Retract;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $retract) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Handle) | undefined;
|
||||
_tmp1 = toHandle(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRetract<_embedded = _.GenericEmbedded>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);}
|
||||
|
||||
export function asMessage<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Message<_embedded> {
|
||||
let result = toMessage(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toMessage<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Message<_embedded> {
|
||||
let result: undefined | Message<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $message) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"body": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromMessage<_embedded = _.GenericEmbedded>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);}
|
||||
|
||||
export function asSync<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Sync<_embedded> {
|
||||
let result = toSync(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSync<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Sync<_embedded> {
|
||||
let result: undefined | Sync<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $sync) ? 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 = {"peer": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromSync<_embedded = _.GenericEmbedded>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);}
|
||||
|
||||
|
|
@ -0,0 +1,359 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const $assert = Symbol.for("assert");
|
||||
export const $error = Symbol.for("error");
|
||||
export const $message = Symbol.for("message");
|
||||
export const $retract = Symbol.for("retract");
|
||||
export const $sync = Symbol.for("sync");
|
||||
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type Packet<_embedded = _i_EntityRef.Ref> = (
|
||||
{"_variant": "Turn", "value": Turn<_embedded>} |
|
||||
{"_variant": "Error", "value": Error<_embedded>}
|
||||
);
|
||||
|
||||
export type Error<_embedded = _i_EntityRef.Ref> = {"message": string, "detail": _.Value<_embedded>};
|
||||
|
||||
export type Assertion<_embedded = _i_EntityRef.Ref> = _.Value<_embedded>;
|
||||
|
||||
export type Handle = number;
|
||||
|
||||
export type Event<_embedded = _i_EntityRef.Ref> = (
|
||||
{"_variant": "Assert", "value": Assert<_embedded>} |
|
||||
{"_variant": "Retract", "value": Retract} |
|
||||
{"_variant": "Message", "value": Message<_embedded>} |
|
||||
{"_variant": "Sync", "value": Sync<_embedded>}
|
||||
);
|
||||
|
||||
export type Oid = number;
|
||||
|
||||
export type Turn<_embedded = _i_EntityRef.Ref> = Array<TurnEvent<_embedded>>;
|
||||
|
||||
export type TurnEvent<_embedded = _i_EntityRef.Ref> = {"oid": Oid, "event": Event<_embedded>};
|
||||
|
||||
export type Assert<_embedded = _i_EntityRef.Ref> = {"assertion": Assertion<_embedded>, "handle": Handle};
|
||||
|
||||
export type Retract = {"handle": Handle};
|
||||
|
||||
export type Message<_embedded = _i_EntityRef.Ref> = {"body": Assertion<_embedded>};
|
||||
|
||||
export type Sync<_embedded = _i_EntityRef.Ref> = {"peer": _embedded};
|
||||
|
||||
|
||||
export namespace Packet {
|
||||
export function Turn<_embedded = _i_EntityRef.Ref>(value: Turn<_embedded>): Packet<_embedded> {return {"_variant": "Turn", "value": value};};
|
||||
export function Error<_embedded = _i_EntityRef.Ref>(value: Error<_embedded>): Packet<_embedded> {return {"_variant": "Error", "value": value};};
|
||||
}
|
||||
|
||||
export function Error<_embedded = _i_EntityRef.Ref>({message, detail}: {message: string, detail: _.Value<_embedded>}): Error<_embedded> {return {"message": message, "detail": detail};}
|
||||
|
||||
export function Assertion<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): Assertion<_embedded> {return value;}
|
||||
|
||||
export function Handle(value: number): Handle {return value;}
|
||||
|
||||
export namespace Event {
|
||||
export function Assert<_embedded = _i_EntityRef.Ref>(value: Assert<_embedded>): Event<_embedded> {return {"_variant": "Assert", "value": value};};
|
||||
export function Retract<_embedded = _i_EntityRef.Ref>(value: Retract): Event<_embedded> {return {"_variant": "Retract", "value": value};};
|
||||
export function Message<_embedded = _i_EntityRef.Ref>(value: Message<_embedded>): Event<_embedded> {return {"_variant": "Message", "value": value};};
|
||||
export function Sync<_embedded = _i_EntityRef.Ref>(value: Sync<_embedded>): Event<_embedded> {return {"_variant": "Sync", "value": value};};
|
||||
}
|
||||
|
||||
export function Oid(value: number): Oid {return value;}
|
||||
|
||||
export function Turn<_embedded = _i_EntityRef.Ref>(value: Array<TurnEvent<_embedded>>): Turn<_embedded> {return value;}
|
||||
|
||||
export function TurnEvent<_embedded = _i_EntityRef.Ref>({oid, event}: {oid: Oid, event: Event<_embedded>}): TurnEvent<_embedded> {return {"oid": oid, "event": event};}
|
||||
|
||||
export function Assert<_embedded = _i_EntityRef.Ref>({assertion, handle}: {assertion: Assertion<_embedded>, handle: Handle}): Assert<_embedded> {return {"assertion": assertion, "handle": handle};}
|
||||
|
||||
export function Retract(handle: Handle): Retract {return {"handle": handle};}
|
||||
|
||||
export function Message<_embedded = _i_EntityRef.Ref>(body: Assertion<_embedded>): Message<_embedded> {return {"body": body};}
|
||||
|
||||
export function Sync<_embedded = _i_EntityRef.Ref>(peer: _embedded): Sync<_embedded> {return {"peer": peer};}
|
||||
|
||||
export function asPacket<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Packet<_embedded> {
|
||||
let result = toPacket(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Packet: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toPacket<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Packet<_embedded> {
|
||||
let _tmp0: (Turn<_embedded>) | undefined;
|
||||
let result: undefined | Packet<_embedded>;
|
||||
_tmp0 = toTurn(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Turn", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Error<_embedded>) | undefined;
|
||||
_tmp1 = toError(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Error", "value": _tmp1};};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromPacket<_embedded = _i_EntityRef.Ref>(_v: Packet<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Turn": {return fromTurn<_embedded>(_v.value);};
|
||||
case "Error": {return fromError<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Error<_embedded> {
|
||||
let result = toError(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Error: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toError<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Error<_embedded> {
|
||||
let result: undefined | Error<_embedded>;
|
||||
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) {
|
||||
let _tmp2: (_.Value<_embedded>) | undefined;
|
||||
_tmp2 = v[1];
|
||||
if (_tmp2 !== void 0) {result = {"message": _tmp1, "detail": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromError<_embedded = _i_EntityRef.Ref>(_v: Error<_embedded>): _.Value<_embedded> {return _.Record($error, [_v["message"], _v["detail"]]);}
|
||||
|
||||
export function asAssertion<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Assertion<_embedded> {
|
||||
let result = toAssertion(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssertion<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Assertion<_embedded> {
|
||||
let _tmp0: (_.Value<_embedded>) | undefined;
|
||||
let result: undefined | Assertion<_embedded>;
|
||||
_tmp0 = v;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssertion<_embedded = _i_EntityRef.Ref>(_v: Assertion<_embedded>): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asHandle<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Handle {
|
||||
let result = toHandle(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toHandle<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Handle {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Handle;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromHandle<_embedded = _i_EntityRef.Ref>(_v: Handle): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Event<_embedded> {
|
||||
let result = toEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Event<_embedded> {
|
||||
let _tmp0: (Assert<_embedded>) | undefined;
|
||||
let result: undefined | Event<_embedded>;
|
||||
_tmp0 = toAssert(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Retract) | undefined;
|
||||
_tmp1 = toRetract(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (Message<_embedded>) | undefined;
|
||||
_tmp2 = toMessage(v);
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
|
||||
if (result === void 0) {
|
||||
let _tmp3: (Sync<_embedded>) | undefined;
|
||||
_tmp3 = toSync(v);
|
||||
if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromEvent<_embedded = _i_EntityRef.Ref>(_v: Event<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "Assert": {return fromAssert<_embedded>(_v.value);};
|
||||
case "Retract": {return fromRetract<_embedded>(_v.value);};
|
||||
case "Message": {return fromMessage<_embedded>(_v.value);};
|
||||
case "Sync": {return fromSync<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Oid {
|
||||
let result = toOid(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toOid<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Oid {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Oid;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromOid<_embedded = _i_EntityRef.Ref>(_v: Oid): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asTurn<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Turn<_embedded> {
|
||||
let result = toTurn(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurn<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Turn<_embedded> {
|
||||
let _tmp0: (Array<TurnEvent<_embedded>>) | undefined;
|
||||
let result: undefined | Turn<_embedded>;
|
||||
_tmp0 = void 0;
|
||||
if (_.Array.isArray(v)) {
|
||||
_tmp0 = [];
|
||||
for (const _tmp1 of v) {
|
||||
let _tmp2: (TurnEvent<_embedded>) | undefined;
|
||||
_tmp2 = toTurnEvent(_tmp1);
|
||||
if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
|
||||
_tmp0 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurn<_embedded = _i_EntityRef.Ref>(_v: Turn<_embedded>): _.Value<_embedded> {return _v.map(v => fromTurnEvent<_embedded>(v));}
|
||||
|
||||
export function asTurnEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TurnEvent<_embedded> {
|
||||
let result = toTurnEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurnEvent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TurnEvent<_embedded> {
|
||||
let result: undefined | TurnEvent<_embedded>;
|
||||
if (_.Array.isArray(v) && v.length === 2) {
|
||||
let _tmp0: (Oid) | undefined;
|
||||
_tmp0 = toOid(v[0]);
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Event<_embedded>) | undefined;
|
||||
_tmp1 = toEvent(v[1]);
|
||||
if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurnEvent<_embedded = _i_EntityRef.Ref>(_v: TurnEvent<_embedded>): _.Value<_embedded> {return [fromOid<_embedded>(_v["oid"]), fromEvent<_embedded>(_v["event"])];}
|
||||
|
||||
export function asAssert<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Assert<_embedded> {
|
||||
let result = toAssert(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssert<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Assert<_embedded> {
|
||||
let result: undefined | Assert<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $assert) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (Handle) | undefined;
|
||||
_tmp2 = toHandle(v[1]);
|
||||
if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssert<_embedded = _i_EntityRef.Ref>(_v: Assert<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
$assert,
|
||||
[fromAssertion<_embedded>(_v["assertion"]), fromHandle<_embedded>(_v["handle"])]
|
||||
);
|
||||
}
|
||||
|
||||
export function asRetract<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Retract {
|
||||
let result = toRetract(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRetract<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Retract {
|
||||
let result: undefined | Retract;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $retract) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Handle) | undefined;
|
||||
_tmp1 = toHandle(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRetract<_embedded = _i_EntityRef.Ref>(_v: Retract): _.Value<_embedded> {return _.Record($retract, [fromHandle<_embedded>(_v["handle"])]);}
|
||||
|
||||
export function asMessage<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Message<_embedded> {
|
||||
let result = toMessage(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toMessage<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Message<_embedded> {
|
||||
let result: undefined | Message<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $message) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion<_embedded>) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"body": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromMessage<_embedded = _i_EntityRef.Ref>(_v: Message<_embedded>): _.Value<_embedded> {return _.Record($message, [fromAssertion<_embedded>(_v["body"])]);}
|
||||
|
||||
export function asSync<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Sync<_embedded> {
|
||||
let result = toSync(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSync<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Sync<_embedded> {
|
||||
let result: undefined | Sync<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $sync) ? 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 = {"peer": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromSync<_embedded = _i_EntityRef.Ref>(_v: Sync<_embedded>): _.Value<_embedded> {return _.Record($sync, [_.embed(_v["peer"])]);}
|
||||
|
||||
|
|
@ -1,291 +0,0 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_sturdy from "./sturdy";
|
||||
|
||||
export const $assert = Symbol.for("assert");
|
||||
export const $message = Symbol.for("message");
|
||||
export const $retract = Symbol.for("retract");
|
||||
export const $sync = Symbol.for("sync");
|
||||
|
||||
export type _embedded = _i_sturdy.WireRef;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
|
||||
export type Assertion = _val;
|
||||
|
||||
export type Handle = number;
|
||||
|
||||
export type Event = (
|
||||
{"_variant": "Assert", "value": Assert} |
|
||||
{"_variant": "Retract", "value": Retract} |
|
||||
{"_variant": "Message", "value": Message} |
|
||||
{"_variant": "Sync", "value": Sync}
|
||||
);
|
||||
|
||||
export type Oid = number;
|
||||
|
||||
export type Turn = Array<TurnEvent>;
|
||||
|
||||
export type TurnEvent = {"oid": Oid, "event": Event};
|
||||
|
||||
export type Assert = {"assertion": Assertion, "handle": Handle};
|
||||
|
||||
export type Retract = {"handle": Handle};
|
||||
|
||||
export type Message = {"body": Assertion};
|
||||
|
||||
export type Sync = {"peer": _embedded};
|
||||
|
||||
|
||||
export function Assertion(value: _val): Assertion {return value;}
|
||||
|
||||
export function Handle(value: number): Handle {return value;}
|
||||
|
||||
export namespace Event {
|
||||
export function Assert(value: Assert): Event {return {"_variant": "Assert", "value": value};};
|
||||
export function Retract(value: Retract): Event {return {"_variant": "Retract", "value": value};};
|
||||
export function Message(value: Message): Event {return {"_variant": "Message", "value": value};};
|
||||
export function Sync(value: Sync): Event {return {"_variant": "Sync", "value": value};};
|
||||
}
|
||||
|
||||
export function Oid(value: number): Oid {return value;}
|
||||
|
||||
export function Turn(value: Array<TurnEvent>): Turn {return value;}
|
||||
|
||||
export function TurnEvent({oid, event}: {oid: Oid, event: Event}): TurnEvent {return {"oid": oid, "event": event};}
|
||||
|
||||
export function Assert({assertion, handle}: {assertion: Assertion, handle: Handle}): Assert {return {"assertion": assertion, "handle": handle};}
|
||||
|
||||
export function Retract(handle: Handle): Retract {return {"handle": handle};}
|
||||
|
||||
export function Message(body: Assertion): Message {return {"body": body};}
|
||||
|
||||
export function Sync(peer: _embedded): Sync {return {"peer": peer};}
|
||||
|
||||
export function asAssertion(v: _val): Assertion {
|
||||
let result = toAssertion(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssertion(v: _val): undefined | Assertion {
|
||||
let _tmp0: (_val) | undefined;
|
||||
let result: undefined | Assertion;
|
||||
_tmp0 = v;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssertion(_v: Assertion): _val {return _v;}
|
||||
|
||||
export function asHandle(v: _val): Handle {
|
||||
let result = toHandle(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toHandle(v: _val): undefined | Handle {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Handle;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromHandle(_v: Handle): _val {return _v;}
|
||||
|
||||
export function asEvent(v: _val): Event {
|
||||
let result = toEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toEvent(v: _val): undefined | Event {
|
||||
let _tmp0: (Assert) | undefined;
|
||||
let result: undefined | Event;
|
||||
_tmp0 = toAssert(v);
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (Retract) | undefined;
|
||||
_tmp1 = toRetract(v);
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (Message) | undefined;
|
||||
_tmp2 = toMessage(v);
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
|
||||
if (result === void 0) {
|
||||
let _tmp3: (Sync) | undefined;
|
||||
_tmp3 = toSync(v);
|
||||
if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromEvent(_v: Event): _val {
|
||||
switch (_v._variant) {
|
||||
case "Assert": {return fromAssert(_v.value);};
|
||||
case "Retract": {return fromRetract(_v.value);};
|
||||
case "Message": {return fromMessage(_v.value);};
|
||||
case "Sync": {return fromSync(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asOid(v: _val): Oid {
|
||||
let result = toOid(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toOid(v: _val): undefined | Oid {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | Oid;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromOid(_v: Oid): _val {return _v;}
|
||||
|
||||
export function asTurn(v: _val): Turn {
|
||||
let result = toTurn(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurn(v: _val): undefined | Turn {
|
||||
let _tmp0: (Array<TurnEvent>) | undefined;
|
||||
let result: undefined | Turn;
|
||||
_tmp0 = void 0;
|
||||
if (_.Array.isArray(v)) {
|
||||
_tmp0 = [];
|
||||
for (const _tmp1 of v) {
|
||||
let _tmp2: (TurnEvent) | undefined;
|
||||
_tmp2 = toTurnEvent(_tmp1);
|
||||
if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
|
||||
_tmp0 = void 0;
|
||||
break;
|
||||
};
|
||||
};
|
||||
if (_tmp0 !== void 0) {result = _tmp0;};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurn(_v: Turn): _val {return _v.map(v => fromTurnEvent(v));}
|
||||
|
||||
export function asTurnEvent(v: _val): TurnEvent {
|
||||
let result = toTurnEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTurnEvent(v: _val): undefined | TurnEvent {
|
||||
let result: undefined | TurnEvent;
|
||||
if (_.Array.isArray(v) && v.length === 2) {
|
||||
let _tmp0: (Oid) | undefined;
|
||||
_tmp0 = toOid(v[0]);
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Event) | undefined;
|
||||
_tmp1 = toEvent(v[1]);
|
||||
if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTurnEvent(_v: TurnEvent): _val {return [fromOid(_v["oid"]), fromEvent(_v["event"])];}
|
||||
|
||||
export function asAssert(v: _val): Assert {
|
||||
let result = toAssert(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toAssert(v: _val): undefined | Assert {
|
||||
let result: undefined | Assert;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $assert) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (Handle) | undefined;
|
||||
_tmp2 = toHandle(v[1]);
|
||||
if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromAssert(_v: Assert): _val {
|
||||
return _.Record($assert, [fromAssertion(_v["assertion"]), fromHandle(_v["handle"])]);
|
||||
}
|
||||
|
||||
export function asRetract(v: _val): Retract {
|
||||
let result = toRetract(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRetract(v: _val): undefined | Retract {
|
||||
let result: undefined | Retract;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $retract) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Handle) | undefined;
|
||||
_tmp1 = toHandle(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRetract(_v: Retract): _val {return _.Record($retract, [fromHandle(_v["handle"])]);}
|
||||
|
||||
export function asMessage(v: _val): Message {
|
||||
let result = toMessage(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toMessage(v: _val): undefined | Message {
|
||||
let result: undefined | Message;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $message) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (Assertion) | undefined;
|
||||
_tmp1 = toAssertion(v[0]);
|
||||
if (_tmp1 !== void 0) {result = {"body": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromMessage(_v: Message): _val {return _.Record($message, [fromAssertion(_v["body"])]);}
|
||||
|
||||
export function asSync(v: _val): Sync {
|
||||
let result = toSync(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSync(v: _val): undefined | Sync {
|
||||
let result: undefined | Sync;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $sync) ? 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 = {"peer": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromSync(_v: Sync): _val {return _.Record($sync, [_.embed(_v["peer"])]);}
|
||||
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
import * as _ from "@preserves/core";
|
||||
|
||||
export const __lit0 = Symbol.for("racket-event");
|
||||
|
||||
export type RacketEvent<_embedded = _.GenericEmbedded> = {"source": _embedded, "event": _embedded};
|
||||
|
||||
|
||||
export function RacketEvent<_embedded = _.GenericEmbedded>({source, event}: {source: _embedded, event: _embedded}): RacketEvent<_embedded> {return {"source": source, "event": event};}
|
||||
|
||||
export function asRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): RacketEvent<_embedded> {
|
||||
let result = toRacketEvent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid RacketEvent: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | RacketEvent<_embedded> {
|
||||
let result: undefined | RacketEvent<_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) {result = {"source": _tmp1, "event": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRacketEvent<_embedded = _.GenericEmbedded>(_v: RacketEvent<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["event"])]);}
|
||||
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const $Observe = Symbol.for("Observe");
|
||||
export const $claimNick = Symbol.for("claimNick");
|
||||
|
|
@ -9,22 +9,20 @@ export const $says = Symbol.for("says");
|
|||
export const $user = Symbol.for("user");
|
||||
export const __lit5 = true;
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type UserId = number;
|
||||
|
||||
export type Join = {"uid": UserId, "handle": _embedded};
|
||||
export type Join<_embedded = _i_EntityRef.Ref> = {"uid": UserId, "handle": _embedded};
|
||||
|
||||
export type Session = (
|
||||
export type Session<_embedded = _i_EntityRef.Ref> = (
|
||||
{"_variant": "observeUsers", "observer": _embedded} |
|
||||
{"_variant": "observeSpeech", "observer": _embedded} |
|
||||
{"_variant": "NickClaim", "value": NickClaim} |
|
||||
{"_variant": "NickClaim", "value": NickClaim<_embedded>} |
|
||||
{"_variant": "Says", "value": Says}
|
||||
);
|
||||
|
||||
export type NickClaim = {"uid": UserId, "name": string, "k": _embedded};
|
||||
export type NickClaim<_embedded = _i_EntityRef.Ref> = {"uid": UserId, "name": string, "k": _embedded};
|
||||
|
||||
export type NickClaimResponse = ({"_variant": "true"} | {"_variant": "NickConflict", "value": NickConflict});
|
||||
|
||||
|
|
@ -37,16 +35,16 @@ export type NickConflict = null;
|
|||
|
||||
export function UserId(value: number): UserId {return value;}
|
||||
|
||||
export function Join({uid, handle}: {uid: UserId, handle: _embedded}): Join {return {"uid": uid, "handle": handle};}
|
||||
export function Join<_embedded = _i_EntityRef.Ref>({uid, handle}: {uid: UserId, handle: _embedded}): Join<_embedded> {return {"uid": uid, "handle": handle};}
|
||||
|
||||
export namespace Session {
|
||||
export function observeUsers(observer: _embedded): Session {return {"_variant": "observeUsers", "observer": observer};};
|
||||
export function observeSpeech(observer: _embedded): Session {return {"_variant": "observeSpeech", "observer": observer};};
|
||||
export function NickClaim(value: NickClaim): Session {return {"_variant": "NickClaim", "value": value};};
|
||||
export function Says(value: Says): Session {return {"_variant": "Says", "value": value};};
|
||||
export function observeUsers<_embedded = _i_EntityRef.Ref>(observer: _embedded): Session<_embedded> {return {"_variant": "observeUsers", "observer": observer};};
|
||||
export function observeSpeech<_embedded = _i_EntityRef.Ref>(observer: _embedded): Session<_embedded> {return {"_variant": "observeSpeech", "observer": observer};};
|
||||
export function NickClaim<_embedded = _i_EntityRef.Ref>(value: NickClaim<_embedded>): Session<_embedded> {return {"_variant": "NickClaim", "value": value};};
|
||||
export function Says<_embedded = _i_EntityRef.Ref>(value: Says): Session<_embedded> {return {"_variant": "Says", "value": value};};
|
||||
}
|
||||
|
||||
export function NickClaim({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim {return {"uid": uid, "name": name, "k": k};}
|
||||
export function NickClaim<_embedded = _i_EntityRef.Ref>({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim<_embedded> {return {"uid": uid, "name": name, "k": k};}
|
||||
|
||||
export namespace NickClaimResponse {
|
||||
export function $true(): NickClaimResponse {return {"_variant": "true"};};
|
||||
|
|
@ -59,13 +57,13 @@ export function Says({who, what}: {who: UserId, what: string}): Says {return {"w
|
|||
|
||||
export function NickConflict(): NickConflict {return null;}
|
||||
|
||||
export function asUserId(v: _val): UserId {
|
||||
export function asUserId<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): UserId {
|
||||
let result = toUserId(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid UserId: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toUserId(v: _val): undefined | UserId {
|
||||
export function toUserId<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | UserId {
|
||||
let _tmp0: (number) | undefined;
|
||||
let result: undefined | UserId;
|
||||
_tmp0 = typeof v === 'number' ? v : void 0;
|
||||
|
|
@ -73,17 +71,17 @@ export function toUserId(v: _val): undefined | UserId {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromUserId(_v: UserId): _val {return _v;}
|
||||
export function fromUserId<_embedded = _i_EntityRef.Ref>(_v: UserId): _.Value<_embedded> {return _v;}
|
||||
|
||||
export function asJoin(v: _val): Join {
|
||||
export function asJoin<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Join<_embedded> {
|
||||
let result = toJoin(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Join: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toJoin(v: _val): undefined | Join {
|
||||
let result: undefined | Join;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toJoin<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Join<_embedded> {
|
||||
let result: undefined | Join<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $joinedUser) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -99,17 +97,19 @@ export function toJoin(v: _val): undefined | Join {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromJoin(_v: Join): _val {return _.Record($joinedUser, [fromUserId(_v["uid"]), _.embed(_v["handle"])]);}
|
||||
export function fromJoin<_embedded = _i_EntityRef.Ref>(_v: Join<_embedded>): _.Value<_embedded> {
|
||||
return _.Record($joinedUser, [fromUserId<_embedded>(_v["uid"]), _.embed(_v["handle"])]);
|
||||
}
|
||||
|
||||
export function asSession(v: _val): Session {
|
||||
export function asSession<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Session<_embedded> {
|
||||
let result = toSession(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Session: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSession(v: _val): undefined | Session {
|
||||
let result: undefined | Session;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toSession<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Session<_embedded> {
|
||||
let result: undefined | Session<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $Observe) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -123,7 +123,7 @@ export function toSession(v: _val): undefined | Session {
|
|||
};
|
||||
};
|
||||
if (result === void 0) {
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp3: (null) | undefined;
|
||||
_tmp3 = _.is(v.label, $Observe) ? null : void 0;
|
||||
if (_tmp3 !== void 0) {
|
||||
|
|
@ -137,7 +137,7 @@ export function toSession(v: _val): undefined | Session {
|
|||
};
|
||||
};
|
||||
if (result === void 0) {
|
||||
let _tmp6: (NickClaim) | undefined;
|
||||
let _tmp6: (NickClaim<_embedded>) | undefined;
|
||||
_tmp6 = toNickClaim(v);
|
||||
if (_tmp6 !== void 0) {result = {"_variant": "NickClaim", "value": _tmp6};};
|
||||
if (result === void 0) {
|
||||
|
|
@ -150,24 +150,24 @@ export function toSession(v: _val): undefined | Session {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromSession(_v: Session): _val {
|
||||
export function fromSession<_embedded = _i_EntityRef.Ref>(_v: Session<_embedded>): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "observeUsers": {return _.Record($Observe, [$user, _.embed(_v["observer"])]);};
|
||||
case "observeSpeech": {return _.Record($Observe, [$says, _.embed(_v["observer"])]);};
|
||||
case "NickClaim": {return fromNickClaim(_v.value);};
|
||||
case "Says": {return fromSays(_v.value);};
|
||||
case "NickClaim": {return fromNickClaim<_embedded>(_v.value);};
|
||||
case "Says": {return fromSays<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asNickClaim(v: _val): NickClaim {
|
||||
export function asNickClaim<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickClaim<_embedded> {
|
||||
let result = toNickClaim(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid NickClaim: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toNickClaim(v: _val): undefined | NickClaim {
|
||||
let result: undefined | NickClaim;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toNickClaim<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickClaim<_embedded> {
|
||||
let result: undefined | NickClaim<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $claimNick) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -187,17 +187,17 @@ export function toNickClaim(v: _val): undefined | NickClaim {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromNickClaim(_v: NickClaim): _val {
|
||||
return _.Record($claimNick, [fromUserId(_v["uid"]), _v["name"], _.embed(_v["k"])]);
|
||||
export function fromNickClaim<_embedded = _i_EntityRef.Ref>(_v: NickClaim<_embedded>): _.Value<_embedded> {
|
||||
return _.Record($claimNick, [fromUserId<_embedded>(_v["uid"]), _v["name"], _.embed(_v["k"])]);
|
||||
}
|
||||
|
||||
export function asNickClaimResponse(v: _val): NickClaimResponse {
|
||||
export function asNickClaimResponse<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickClaimResponse {
|
||||
let result = toNickClaimResponse(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid NickClaimResponse: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toNickClaimResponse(v: _val): undefined | NickClaimResponse {
|
||||
export function toNickClaimResponse<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickClaimResponse {
|
||||
let _tmp0: (null) | undefined;
|
||||
let result: undefined | NickClaimResponse;
|
||||
_tmp0 = _.is(v, __lit5) ? null : void 0;
|
||||
|
|
@ -210,22 +210,22 @@ export function toNickClaimResponse(v: _val): undefined | NickClaimResponse {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromNickClaimResponse(_v: NickClaimResponse): _val {
|
||||
export function fromNickClaimResponse<_embedded = _i_EntityRef.Ref>(_v: NickClaimResponse): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "true": {return __lit5;};
|
||||
case "NickConflict": {return fromNickConflict(_v.value);};
|
||||
case "NickConflict": {return fromNickConflict<_embedded>(_v.value);};
|
||||
};
|
||||
}
|
||||
|
||||
export function asUserInfo(v: _val): UserInfo {
|
||||
export function asUserInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): UserInfo {
|
||||
let result = toUserInfo(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid UserInfo: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toUserInfo(v: _val): undefined | UserInfo {
|
||||
export function toUserInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | UserInfo {
|
||||
let result: undefined | UserInfo;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $user) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -241,17 +241,17 @@ export function toUserInfo(v: _val): undefined | UserInfo {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromUserInfo(_v: UserInfo): _val {return _.Record($user, [fromUserId(_v["uid"]), _v["name"]]);}
|
||||
export function fromUserInfo<_embedded = _i_EntityRef.Ref>(_v: UserInfo): _.Value<_embedded> {return _.Record($user, [fromUserId<_embedded>(_v["uid"]), _v["name"]]);}
|
||||
|
||||
export function asSays(v: _val): Says {
|
||||
export function asSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Says {
|
||||
let result = toSays(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSays(v: _val): undefined | Says {
|
||||
export function toSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Says {
|
||||
let result: undefined | Says;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $says) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -267,17 +267,17 @@ export function toSays(v: _val): undefined | Says {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromSays(_v: Says): _val {return _.Record($says, [fromUserId(_v["who"]), _v["what"]]);}
|
||||
export function fromSays<_embedded = _i_EntityRef.Ref>(_v: Says): _.Value<_embedded> {return _.Record($says, [fromUserId<_embedded>(_v["who"]), _v["what"]]);}
|
||||
|
||||
export function asNickConflict(v: _val): NickConflict {
|
||||
export function asNickConflict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): NickConflict {
|
||||
let result = toNickConflict(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid NickConflict: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toNickConflict(v: _val): undefined | NickConflict {
|
||||
export function toNickConflict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | NickConflict {
|
||||
let result: undefined | NickConflict;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $nickConflict) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {result = null;};
|
||||
|
|
@ -285,5 +285,5 @@ export function toNickConflict(v: _val): undefined | NickConflict {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromNickConflict(_v: NickConflict): _val {return _.Record($nickConflict, []);}
|
||||
export function fromNickConflict<_embedded = _i_EntityRef.Ref>(_v: NickConflict): _.Value<_embedded> {return _.Record($nickConflict, []);}
|
||||
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const __lit0 = Symbol.for("require-service");
|
||||
export const __lit1 = Symbol.for("service-running");
|
||||
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type RequireService<_embedded = _i_EntityRef.Ref> = {"serviceName": _.Value<_embedded>};
|
||||
|
||||
export type ServiceRunning<_embedded = _i_EntityRef.Ref> = {"serviceName": _.Value<_embedded>};
|
||||
|
||||
|
||||
export function RequireService<_embedded = _i_EntityRef.Ref>(serviceName: _.Value<_embedded>): RequireService<_embedded> {return {"serviceName": serviceName};}
|
||||
|
||||
export function ServiceRunning<_embedded = _i_EntityRef.Ref>(serviceName: _.Value<_embedded>): ServiceRunning<_embedded> {return {"serviceName": serviceName};}
|
||||
|
||||
export function asRequireService<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): RequireService<_embedded> {
|
||||
let result = toRequireService(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid RequireService: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toRequireService<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | RequireService<_embedded> {
|
||||
let result: undefined | RequireService<_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: (_.Value<_embedded>) | undefined;
|
||||
_tmp1 = v[0];
|
||||
if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromRequireService<_embedded = _i_EntityRef.Ref>(_v: RequireService<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_v["serviceName"]]);}
|
||||
|
||||
export function asServiceRunning<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): ServiceRunning<_embedded> {
|
||||
let result = toServiceRunning(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid ServiceRunning: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toServiceRunning<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | ServiceRunning<_embedded> {
|
||||
let result: undefined | ServiceRunning<_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 = {"serviceName": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromServiceRunning<_embedded = _i_EntityRef.Ref>(_v: ServiceRunning<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["serviceName"]]);}
|
||||
|
||||
|
|
@ -1,12 +1,10 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const $Present = Symbol.for("Present");
|
||||
export const $Says = Symbol.for("Says");
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type Present = {"username": string};
|
||||
|
||||
|
|
@ -17,15 +15,15 @@ export function Present(username: string): Present {return {"username": username
|
|||
|
||||
export function Says({who, what}: {who: string, what: string}): Says {return {"who": who, "what": what};}
|
||||
|
||||
export function asPresent(v: _val): Present {
|
||||
export function asPresent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Present {
|
||||
let result = toPresent(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Present: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toPresent(v: _val): undefined | Present {
|
||||
export function toPresent<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Present {
|
||||
let result: undefined | Present;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $Present) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -37,17 +35,17 @@ export function toPresent(v: _val): undefined | Present {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromPresent(_v: Present): _val {return _.Record($Present, [_v["username"]]);}
|
||||
export function fromPresent<_embedded = _i_EntityRef.Ref>(_v: Present): _.Value<_embedded> {return _.Record($Present, [_v["username"]]);}
|
||||
|
||||
export function asSays(v: _val): Says {
|
||||
export function asSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Says {
|
||||
let result = toSays(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSays(v: _val): undefined | Says {
|
||||
export function toSays<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Says {
|
||||
let result: undefined | Says;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $Says) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
|
|
@ -63,5 +61,5 @@ export function toSays(v: _val): undefined | Says {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromSays(_v: Says): _val {return _.Record($Says, [_v["who"], _v["what"]]);}
|
||||
export function fromSays<_embedded = _i_EntityRef.Ref>(_v: Says): _.Value<_embedded> {return _.Record($Says, [_v["who"], _v["what"]]);}
|
||||
|
||||
|
|
@ -0,0 +1,401 @@
|
|||
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;};};
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,115 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const __lit0 = Symbol.for("tcp-remote");
|
||||
export const __lit1 = Symbol.for("tcp-local");
|
||||
export const __lit2 = Symbol.for("tcp-peer");
|
||||
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type TcpRemote = {"host": string, "port": number};
|
||||
|
||||
export type TcpLocal = {"host": string, "port": number};
|
||||
|
||||
export type TcpPeerInfo<_embedded = _i_EntityRef.Ref> = {"handle": _embedded, "local": TcpLocal, "remote": TcpRemote};
|
||||
|
||||
|
||||
export function TcpRemote({host, port}: {host: string, port: number}): TcpRemote {return {"host": host, "port": port};}
|
||||
|
||||
export function TcpLocal({host, port}: {host: string, port: number}): TcpLocal {return {"host": host, "port": port};}
|
||||
|
||||
export function TcpPeerInfo<_embedded = _i_EntityRef.Ref>(
|
||||
{handle, local, remote}: {handle: _embedded, local: TcpLocal, remote: TcpRemote}
|
||||
): TcpPeerInfo<_embedded> {return {"handle": handle, "local": local, "remote": remote};}
|
||||
|
||||
export function asTcpRemote<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpRemote {
|
||||
let result = toTcpRemote(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TcpRemote: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTcpRemote<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpRemote {
|
||||
let result: undefined | TcpRemote;
|
||||
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: (string) | undefined;
|
||||
_tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (number) | undefined;
|
||||
_tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTcpRemote<_embedded = _i_EntityRef.Ref>(_v: TcpRemote): _.Value<_embedded> {return _.Record(__lit0, [_v["host"], _v["port"]]);}
|
||||
|
||||
export function asTcpLocal<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpLocal {
|
||||
let result = toTcpLocal(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TcpLocal: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTcpLocal<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpLocal {
|
||||
let result: undefined | TcpLocal;
|
||||
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: (string) | undefined;
|
||||
_tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (number) | undefined;
|
||||
_tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTcpLocal<_embedded = _i_EntityRef.Ref>(_v: TcpLocal): _.Value<_embedded> {return _.Record(__lit1, [_v["host"], _v["port"]]);}
|
||||
|
||||
export function asTcpPeerInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): TcpPeerInfo<_embedded> {
|
||||
let result = toTcpPeerInfo(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TcpPeerInfo: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTcpPeerInfo<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | TcpPeerInfo<_embedded> {
|
||||
let result: undefined | TcpPeerInfo<_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: (_embedded) | undefined;
|
||||
_tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (TcpLocal) | undefined;
|
||||
_tmp2 = toTcpLocal(v[1]);
|
||||
if (_tmp2 !== void 0) {
|
||||
let _tmp3: (TcpRemote) | undefined;
|
||||
_tmp3 = toTcpRemote(v[2]);
|
||||
if (_tmp3 !== void 0) {result = {"handle": _tmp1, "local": _tmp2, "remote": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTcpPeerInfo<_embedded = _i_EntityRef.Ref>(_v: TcpPeerInfo<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
__lit2,
|
||||
[
|
||||
_.embed(_v["handle"]),
|
||||
fromTcpLocal<_embedded>(_v["local"]),
|
||||
fromTcpRemote<_embedded>(_v["remote"])
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
import * as _ from "@preserves/core";
|
||||
|
||||
export const $absolute = Symbol.for("absolute");
|
||||
export const $clear = Symbol.for("clear");
|
||||
export const $relative = Symbol.for("relative");
|
||||
export const __lit0 = Symbol.for("set-timer");
|
||||
export const __lit1 = Symbol.for("timer-expired");
|
||||
export const __lit5 = Symbol.for("later-than");
|
||||
|
||||
export type SetTimer<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number, "kind": TimerKind};
|
||||
|
||||
export type TimerExpired<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number};
|
||||
|
||||
export type TimerKind = ({"_variant": "relative"} | {"_variant": "absolute"} | {"_variant": "clear"});
|
||||
|
||||
export type LaterThan = {"msecs": number};
|
||||
|
||||
|
||||
export function SetTimer<_embedded = _.GenericEmbedded>(
|
||||
{label, msecs, kind}: {label: _.Value<_embedded>, msecs: number, kind: TimerKind}
|
||||
): SetTimer<_embedded> {return {"label": label, "msecs": msecs, "kind": kind};}
|
||||
|
||||
export function TimerExpired<_embedded = _.GenericEmbedded>({label, msecs}: {label: _.Value<_embedded>, msecs: number}): TimerExpired<_embedded> {return {"label": label, "msecs": msecs};}
|
||||
|
||||
export namespace TimerKind {
|
||||
export function relative(): TimerKind {return {"_variant": "relative"};};
|
||||
export function absolute(): TimerKind {return {"_variant": "absolute"};};
|
||||
export function clear(): TimerKind {return {"_variant": "clear"};};
|
||||
}
|
||||
|
||||
export function LaterThan(msecs: number): LaterThan {return {"msecs": msecs};}
|
||||
|
||||
export function asSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): SetTimer<_embedded> {
|
||||
let result = toSetTimer(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid SetTimer: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SetTimer<_embedded> {
|
||||
let result: undefined | SetTimer<_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: (_.Value<_embedded>) | undefined;
|
||||
_tmp1 = v[0];
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (number) | undefined;
|
||||
_tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0;
|
||||
if (_tmp2 !== void 0) {
|
||||
let _tmp3: (TimerKind) | undefined;
|
||||
_tmp3 = toTimerKind(v[2]);
|
||||
if (_tmp3 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2, "kind": _tmp3};};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromSetTimer<_embedded = _.GenericEmbedded>(_v: SetTimer<_embedded>): _.Value<_embedded> {
|
||||
return _.Record(
|
||||
__lit0,
|
||||
[_v["label"], _.Double(_v["msecs"]), fromTimerKind<_embedded>(_v["kind"])]
|
||||
);
|
||||
}
|
||||
|
||||
export function asTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerExpired<_embedded> {
|
||||
let result = toTimerExpired(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TimerExpired: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerExpired<_embedded> {
|
||||
let result: undefined | TimerExpired<_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) {
|
||||
let _tmp2: (number) | undefined;
|
||||
_tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2};};
|
||||
};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTimerExpired<_embedded = _.GenericEmbedded>(_v: TimerExpired<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["label"], _.Double(_v["msecs"])]);}
|
||||
|
||||
export function asTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerKind {
|
||||
let result = toTimerKind(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid TimerKind: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerKind {
|
||||
let _tmp0: (null) | undefined;
|
||||
let result: undefined | TimerKind;
|
||||
_tmp0 = _.is(v, $relative) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {result = {"_variant": "relative"};};
|
||||
if (result === void 0) {
|
||||
let _tmp1: (null) | undefined;
|
||||
_tmp1 = _.is(v, $absolute) ? null : void 0;
|
||||
if (_tmp1 !== void 0) {result = {"_variant": "absolute"};};
|
||||
if (result === void 0) {
|
||||
let _tmp2: (null) | undefined;
|
||||
_tmp2 = _.is(v, $clear) ? null : void 0;
|
||||
if (_tmp2 !== void 0) {result = {"_variant": "clear"};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromTimerKind<_embedded = _.GenericEmbedded>(_v: TimerKind): _.Value<_embedded> {
|
||||
switch (_v._variant) {
|
||||
case "relative": {return $relative;};
|
||||
case "absolute": {return $absolute;};
|
||||
case "clear": {return $clear;};
|
||||
};
|
||||
}
|
||||
|
||||
export function asLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): LaterThan {
|
||||
let result = toLaterThan(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid LaterThan: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | LaterThan {
|
||||
let result: undefined | LaterThan;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, __lit5) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (number) | undefined;
|
||||
_tmp1 = _.Float.isDouble(v[0]) ? v[0].value : void 0;
|
||||
if (_tmp1 !== void 0) {result = {"msecs": _tmp1};};
|
||||
};
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
export function fromLaterThan<_embedded = _.GenericEmbedded>(_v: LaterThan): _.Value<_embedded> {return _.Record(__lit5, [_.Double(_v["msecs"])]);}
|
||||
|
||||
|
|
@ -1,33 +1,31 @@
|
|||
import * as _ from "@preserves/core";
|
||||
import * as _i_Actor from "../runtime/actor";
|
||||
import * as _i_EntityRef from "../runtime/actor";
|
||||
|
||||
export const $Instance = Symbol.for("Instance");
|
||||
|
||||
export type _embedded = _i_Actor.Ref;
|
||||
export type _embedded = _i_EntityRef.Ref;
|
||||
|
||||
export type _val = _.Value<_embedded>;
|
||||
|
||||
export type Instance = {"name": string, "argument": _val};
|
||||
export type Instance<_embedded = _i_EntityRef.Ref> = {"name": string, "argument": _.Value<_embedded>};
|
||||
|
||||
|
||||
export function Instance({name, argument}: {name: string, argument: _val}): Instance {return {"name": name, "argument": argument};}
|
||||
export function Instance<_embedded = _i_EntityRef.Ref>({name, argument}: {name: string, argument: _.Value<_embedded>}): Instance<_embedded> {return {"name": name, "argument": argument};}
|
||||
|
||||
export function asInstance(v: _val): Instance {
|
||||
export function asInstance<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Instance<_embedded> {
|
||||
let result = toInstance(v);
|
||||
if (result === void 0) throw new TypeError(`Invalid Instance: ${_.stringify(v)}`);
|
||||
return result;
|
||||
}
|
||||
|
||||
export function toInstance(v: _val): undefined | Instance {
|
||||
let result: undefined | Instance;
|
||||
if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
|
||||
export function toInstance<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Instance<_embedded> {
|
||||
let result: undefined | Instance<_embedded>;
|
||||
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
||||
let _tmp0: (null) | undefined;
|
||||
_tmp0 = _.is(v.label, $Instance) ? null : void 0;
|
||||
if (_tmp0 !== void 0) {
|
||||
let _tmp1: (string) | undefined;
|
||||
_tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
|
||||
if (_tmp1 !== void 0) {
|
||||
let _tmp2: (_val) | undefined;
|
||||
let _tmp2: (_.Value<_embedded>) | undefined;
|
||||
_tmp2 = v[1];
|
||||
if (_tmp2 !== void 0) {result = {"name": _tmp1, "argument": _tmp2};};
|
||||
};
|
||||
|
|
@ -36,5 +34,5 @@ export function toInstance(v: _val): undefined | Instance {
|
|||
return result;
|
||||
}
|
||||
|
||||
export function fromInstance(_v: Instance): _val {return _.Record($Instance, [_v["name"], _v["argument"]]);}
|
||||
export function fromInstance<_embedded = _i_EntityRef.Ref>(_v: Instance<_embedded>): _.Value<_embedded> {return _.Record($Instance, [_v["name"], _v["argument"]]);}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,8 @@ import { IdentitySet, Value } from '@preserves/core';
|
|||
import { Attenuation, runRewrites } from './rewrite.js';
|
||||
import { queueTask } from './task.js';
|
||||
|
||||
export type AnyValue = Value<Ref>;
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
if ('stackTraceLimit' in Error) {
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
import { Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor';
|
||||
import { Dictionary, IdentityMap, is, Record, Tuple } from '@preserves/core';
|
||||
import { Bag, ChangeDescription } from './bag';
|
||||
import { KeyedDictionary, preserves } from '@preserves/core';
|
||||
import { AnyValue, Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor';
|
||||
|
||||
import { fromObserve, toObserve, Observe } from '../gen/dataspace';
|
||||
export * from '../gen/dataspace';
|
||||
import { fromObserve, Observe } from '../gen/dataspace';
|
||||
import { DBind, DDiscard, DLit, Pattern, DCompound, CArr, CDict, CRec } from '../gen/dataspacePatterns';
|
||||
|
||||
export { asObserve, fromObserve, toObserve, Observe, $Observe } from '../gen/dataspace';
|
||||
export * from '../gen/dataspacePatterns';
|
||||
|
||||
// Q. Why keep "Observe"? Why not do the clever trick of asserting the
|
||||
// observer, and having the dataspace read the implicit pattern it's
|
||||
|
|
@ -36,54 +38,19 @@ export * from '../gen/dataspace';
|
|||
// spurious variation.
|
||||
|
||||
export class Dataspace implements Partial<Entity> {
|
||||
readonly handleMap: IdentityMap<Handle, Record<Assertion, any, Ref>> = new IdentityMap();
|
||||
readonly assertions = new Bag<Ref>();
|
||||
readonly subscriptions = new Dictionary<Ref, Map<Ref, Dictionary<Ref, Handle>>>();
|
||||
|
||||
assert(turn: Turn, rec: Assertion, handle: Handle): void {
|
||||
// console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`);
|
||||
if (!Record.isRecord<Assertion, Tuple<Assertion>, Ref>(rec)) return;
|
||||
this.handleMap.set(handle, rec);
|
||||
if (this.assertions.change(rec, +1) !== ChangeDescription.ABSENT_TO_PRESENT) return;
|
||||
{
|
||||
const o = toObserve(rec);
|
||||
if (o !== void 0) {
|
||||
const seen = new Dictionary<Ref, Handle>();
|
||||
if (!this.subscriptions.has(o.label)) this.subscriptions.set(o.label, new Map());
|
||||
this.subscriptions.get(o.label)!.set(o.observer, seen);
|
||||
this.assertions.forEach((_count, prev) =>
|
||||
is((prev as Record<Assertion, any, Ref>).label, o.label)
|
||||
&& seen.set(prev, turn.assert(o.observer, prev)));
|
||||
}
|
||||
}
|
||||
this.subscriptions.get(rec.label)?.forEach((seen, peer) =>
|
||||
seen.has(rec) || seen.set(rec, turn.assert(peer, rec)));
|
||||
console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`);
|
||||
throw new Error("Full dataspaces not implemented");
|
||||
}
|
||||
|
||||
retract(turn: Turn, upstreamHandle: Handle): void {
|
||||
const rec = this.handleMap.get(upstreamHandle);
|
||||
// console.log(preserves`ds ${turn.activeFacet.id} retract ${rec} ${upstreamHandle}`);
|
||||
if (rec === void 0) return;
|
||||
this.handleMap.delete(upstreamHandle);
|
||||
if (this.assertions.change(rec, -1) !== ChangeDescription.PRESENT_TO_ABSENT) return;
|
||||
this.subscriptions.get(rec.label)?.forEach((seen, _peer) => {
|
||||
turn.retract(seen.get(rec));
|
||||
seen.delete(rec);
|
||||
});
|
||||
{
|
||||
const o = toObserve(rec);
|
||||
if (o !== void 0) {
|
||||
let peerMap = this.subscriptions.get(o.label)!;
|
||||
peerMap.delete(o.observer);
|
||||
if (peerMap.size === 0) this.subscriptions.delete(o.label);
|
||||
}
|
||||
}
|
||||
console.log(preserves`ds ${turn.activeFacet.id} retract ${upstreamHandle}`);
|
||||
throw new Error("Full dataspaces not implemented");
|
||||
}
|
||||
|
||||
message(turn: Turn, rec: Assertion): void {
|
||||
// console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`);
|
||||
if (!Record.isRecord<Assertion, Tuple<Assertion>, Ref>(rec)) return;
|
||||
this.subscriptions.get(rec.label)?.forEach((_seen, peer) => turn.message(peer, rec));
|
||||
console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`);
|
||||
throw new Error("Full dataspaces not implemented");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -124,6 +91,46 @@ export function during(f: (t: Turn, a: Assertion) => Promise<LocalAction | null>
|
|||
};
|
||||
}
|
||||
|
||||
export function observe(t: Turn, ds: Ref, label: symbol, e: Partial<Entity>): Handle {
|
||||
return t.assert(ds, fromObserve(Observe({ label, observer: t.ref(e) })));
|
||||
export function observe(t: Turn, ds: Ref, pattern: Pattern, e: Partial<Entity>): Handle {
|
||||
return t.assert(ds, fromObserve(Observe({ pattern, observer: t.ref(e) })));
|
||||
}
|
||||
|
||||
export namespace P {
|
||||
export function discard(): Pattern {
|
||||
return Pattern.DDiscard(DDiscard());
|
||||
}
|
||||
export function bind(name: string, pattern: Pattern = discard()): Pattern {
|
||||
return Pattern.DBind(DBind({name: Symbol.for(name), pattern}));
|
||||
}
|
||||
export function lit(value: AnyValue): Pattern {
|
||||
return Pattern.DLit(DLit(value));
|
||||
}
|
||||
export function rec(label: AnyValue, ...fields: Pattern[]): Pattern {
|
||||
const members = new KeyedDictionary<number, Pattern, Ref>();
|
||||
fields.forEach((f, i) => {
|
||||
if (f._variant !== 'DDiscard') members.set(i, f);
|
||||
});
|
||||
return Pattern.DCompound(DCompound.rec({
|
||||
ctor: CRec({ label, arity: fields.length }),
|
||||
members,
|
||||
}));
|
||||
}
|
||||
export function arr(...entries: Pattern[]): Pattern {
|
||||
const members = new KeyedDictionary<number, Pattern, Ref>();
|
||||
entries.forEach((f, i) => {
|
||||
if (f._variant !== 'DDiscard') members.set(i, f);
|
||||
});
|
||||
return Pattern.DCompound(DCompound.arr({
|
||||
ctor: CArr(entries.length),
|
||||
members,
|
||||
}));
|
||||
}
|
||||
export function dict(...entries: [AnyValue, Pattern][]): Pattern {
|
||||
const members = new KeyedDictionary<AnyValue, Pattern, Ref>();
|
||||
entries.forEach(([k, p]) => members.set(k, p));
|
||||
return Pattern.DCompound(DCompound.dict({
|
||||
ctor: CDict(),
|
||||
members,
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
import type { Assertion, Handle, Ref, Turn } from "./actor.js";
|
||||
import { Bytes, Dictionary, DoubleFloat, embed, IdentityMap, is, isEmbedded, Record, SingleFloat, Tuple } from "@preserves/core";
|
||||
import { SturdyValue } from "../transport/sturdy.js";
|
||||
|
||||
import {
|
||||
Alts,
|
||||
|
|
@ -22,7 +23,6 @@ import {
|
|||
Rewrite,
|
||||
TRef,
|
||||
Template,
|
||||
_val,
|
||||
_embedded,
|
||||
} from '../gen/sturdy.js';
|
||||
export * from '../gen/sturdy.js';
|
||||
|
|
@ -237,7 +237,7 @@ export function forwarder(t: Turn, ref: Ref): { proxy: Ref, revoker: Ref } {
|
|||
return { proxy, revoker };
|
||||
}
|
||||
|
||||
export function pRec(label: _val, ... members: Array<Pattern>): Pattern {
|
||||
export function pRec(label: SturdyValue, ... members: Array<Pattern>): Pattern {
|
||||
return Pattern.PCompound(PCompound({
|
||||
ctor: ConstructorSpec.CRec(CRec({ label: label, arity: members.length })),
|
||||
members: PCompoundMembers(new Dictionary<_embedded, Pattern>(
|
||||
|
|
@ -251,13 +251,13 @@ export function pArr(... members: Array<Pattern>): Pattern {
|
|||
members.map((p, i) => [i, p] as const).filter(e => e[1]._variant !== 'PDiscard')))}));
|
||||
}
|
||||
|
||||
export function pDict(... entries: [_val, Pattern][]): Pattern {
|
||||
export function pDict(... entries: [SturdyValue, Pattern][]): Pattern {
|
||||
return Pattern.PCompound(PCompound({
|
||||
ctor: ConstructorSpec.CDict(CDict()),
|
||||
members: PCompoundMembers(new Dictionary<_embedded, Pattern>(entries))}));
|
||||
}
|
||||
|
||||
export function pLit(value: _val): Pattern {
|
||||
export function pLit(value: SturdyValue): Pattern {
|
||||
return Pattern.Lit(Lit(value));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
import * as S from '../gen/sturdy.js';
|
||||
import * as IO from '../gen/protocol.js';
|
||||
import * as IO from '../gen/externalProtocol.js';
|
||||
import { Ref } from '../runtime/actor.js';
|
||||
import { Decoder, DecoderState, Encoder, EncoderState, GenericEmbedded, neverEmbeddedType, EmbeddedType, Value } from '@preserves/core';
|
||||
|
||||
|
|
@ -15,7 +15,7 @@ export const wireRefEmbeddedType: EmbeddedType<S.WireRef> = {
|
|||
},
|
||||
|
||||
fromValue(v: Value<GenericEmbedded>): S.WireRef {
|
||||
return S.asWireRef(v as S._val);
|
||||
return S.asWireRef(v as Value<S._embedded>);
|
||||
},
|
||||
|
||||
toValue(v: S.WireRef): Value<GenericEmbedded> {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
import { Actor, Assertion, Entity, Facet, Handle, Ref, Turn } from '../runtime/actor.js';
|
||||
import { BytesLike, Decoder, Dictionary, embed, encode, IdentityMap, mapEmbeddeds, underlying, Value } from '@preserves/core';
|
||||
import * as IO from '../gen/protocol.js';
|
||||
import * as IO from '../gen/externalProtocol.js';
|
||||
import { wireRefEmbeddedType, WireSymbol } from './protocol.js';
|
||||
import { queueTask } from '../runtime/task.js';
|
||||
import { attenuate } from '../runtime/rewrite.js';
|
||||
|
|
|
|||
|
|
@ -7,11 +7,11 @@
|
|||
// California: Internet Society, 2014.
|
||||
|
||||
import { mac } from './cryptography.js';
|
||||
import { Bytes, decode, encode, is, neverEmbeddedType } from '@preserves/core';
|
||||
import { Bytes, decode, encode, is, neverEmbeddedType, Value } from '@preserves/core';
|
||||
import * as S from '../gen/sturdy.js';
|
||||
export * from '../gen/sturdy.js';
|
||||
|
||||
export type SturdyValue = S._val;
|
||||
export type SturdyValue = Value<S._embedded>;
|
||||
|
||||
export const KEY_LENGTH = 16; // 128 bits
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue