@skipruntime/core 0.0.2 → 0.0.4

package/src/index.js

@@ -0,0 +1,742 @@
+"use strict";
+/**
+ * The @skipruntime/core package contains internal implementation detail for the Skip Framework and should not need to be used directly. See the public API exposed by the @skipruntime/helpers package.
+ *
+ * @packageDocumentation
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBinding = exports.ServiceInstance = exports.ServiceInstanceFactory = exports.Refs = exports.Stack = exports.Count = exports.Max = exports.Min = exports.Sum = exports.isSkManaged = exports.sk_freeze = exports.UnknownCollectionError = void 0;
+var json_1 = require("@skiplang/json");
+Object.defineProperty(exports, "sk_freeze", { enumerable: true, get: function () { return json_1.sk_freeze; } });
+Object.defineProperty(exports, "isSkManaged", { enumerable: true, get: function () { return json_1.isSkManaged; } });
+var std_1 = require("@skiplang/std");
+var api_1 = require("@skipruntime/api");
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "UnknownCollectionError", { enumerable: true, get: function () { return errors_js_1.UnknownCollectionError; } });
+var binding_js_1 = require("./binding.js");
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "Sum", { enumerable: true, get: function () { return utils_js_1.Sum; } });
+Object.defineProperty(exports, "Min", { enumerable: true, get: function () { return utils_js_1.Min; } });
+Object.defineProperty(exports, "Max", { enumerable: true, get: function () { return utils_js_1.Max; } });
+Object.defineProperty(exports, "Count", { enumerable: true, get: function () { return utils_js_1.Count; } });
+var Handles = /** @class */ (function () {
+    function Handles() {
+        this.nextID = 1;
+        this.objects = [];
+        this.freeIDs = [];
+    }
+    Handles.prototype.register = function (v) {
+        var freeID = this.freeIDs.pop();
+        var id = freeID !== null && freeID !== void 0 ? freeID : this.nextID++;
+        this.objects[id] = v;
+        return id;
+    };
+    Handles.prototype.get = function (id) {
+        return this.objects[id];
+    };
+    Handles.prototype.apply = function (id, parameters) {
+        var fn = this.get(id);
+        return fn.apply(null, parameters);
+    };
+    Handles.prototype.deleteHandle = function (id) {
+        var current = this.get(id);
+        this.objects[id] = null;
+        this.freeIDs.push(id);
+        return current;
+    };
+    return Handles;
+}());
+var Stack = /** @class */ (function () {
+    function Stack() {
+        this.stack = [];
+    }
+    Stack.prototype.push = function (pointer) {
+        this.stack.push(pointer);
+    };
+    Stack.prototype.get = function () {
+        if (this.stack.length == 0)
+            return null;
+        return this.stack[this.stack.length - 1];
+    };
+    Stack.prototype.pop = function () {
+        this.stack.pop();
+    };
+    return Stack;
+}());
+exports.Stack = Stack;
+var Refs = /** @class */ (function () {
+    function Refs(binding, skjson, handles, needGC, runWithGC) {
+        this.binding = binding;
+        this.skjson = skjson;
+        this.handles = handles;
+        this.needGC = needGC;
+        this.runWithGC = runWithGC;
+    }
+    return Refs;
+}());
+exports.Refs = Refs;
+var LazyCollectionImpl = /** @class */ (function (_super) {
+    __extends(LazyCollectionImpl, _super);
+    function LazyCollectionImpl(lazyCollection, refs) {
+        var _this = _super.call(this) || this;
+        _this.lazyCollection = lazyCollection;
+        _this.refs = refs;
+        Object.freeze(_this);
+        return _this;
+    }
+    LazyCollectionImpl.prototype.getArray = function (key) {
+        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_LazyCollection__getArray(this.lazyCollection, this.refs.skjson.exportJSON(key)));
+    };
+    LazyCollectionImpl.prototype.getUnique = function (key) {
+        var v = this.refs.skjson.importOptJSON(this.refs.binding.SkipRuntime_LazyCollection__getUnique(this.lazyCollection, this.refs.skjson.exportJSON(key)));
+        if (v == null)
+            throw new api_1.NonUniqueValueException();
+        return v;
+    };
+    return LazyCollectionImpl;
+}(json_1.SkManaged));
+var EagerCollectionImpl = /** @class */ (function (_super) {
+    __extends(EagerCollectionImpl, _super);
+    function EagerCollectionImpl(collection, refs) {
+        var _this = _super.call(this) || this;
+        _this.collection = collection;
+        _this.refs = refs;
+        _this.size = function () {
+            return Number(_this.refs.binding.SkipRuntime_Collection__size(_this.collection));
+        };
+        Object.freeze(_this);
+        return _this;
+    }
+    EagerCollectionImpl.prototype.getArray = function (key) {
+        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_Collection__getArray(this.collection, this.refs.skjson.exportJSON(key)));
+    };
+    EagerCollectionImpl.prototype.getUnique = function (key) {
+        var v = this.refs.skjson.importOptJSON(this.refs.binding.SkipRuntime_Collection__getUnique(this.collection, this.refs.skjson.exportJSON(key)));
+        if (v == null)
+            throw new api_1.NonUniqueValueException();
+        return v;
+    };
+    EagerCollectionImpl.prototype.slice = function (start, end) {
+        return this.slices([start, end]);
+    };
+    EagerCollectionImpl.prototype.slices = function () {
+        var ranges = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            ranges[_i] = arguments[_i];
+        }
+        var skcollection = this.refs.binding.SkipRuntime_Collection__slice(this.collection, this.refs.skjson.exportJSON(ranges));
+        return this.derive(skcollection);
+    };
+    EagerCollectionImpl.prototype.take = function (limit) {
+        var skcollection = this.refs.binding.SkipRuntime_Collection__take(this.collection, BigInt(limit));
+        return this.derive(skcollection);
+    };
+    EagerCollectionImpl.prototype.map = function (mapper) {
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        var mapperParams = params.map(json_1.checkOrCloneParam);
+        var mapperObj = new (mapper.bind.apply(mapper, __spreadArray([void 0], mapperParams, false)))();
+        Object.freeze(mapperObj);
+        if (!mapperObj.constructor.name) {
+            throw new Error("Mapper classes must be defined at top-level.");
+        }
+        var skmapper = this.refs.binding.SkipRuntime_createMapper(this.refs.handles.register(mapperObj));
+        var mapped = this.refs.binding.SkipRuntime_Collection__map(this.collection, skmapper);
+        return this.derive(mapped);
+    };
+    EagerCollectionImpl.prototype.mapReduce = function (mapper) {
+        var _this = this;
+        var mapperParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            mapperParams[_i - 1] = arguments[_i];
+        }
+        return function (reducer) {
+            var reducerParams = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                reducerParams[_i - 1] = arguments[_i];
+            }
+            var mParams = mapperParams.map(json_1.checkOrCloneParam);
+            var rParams = reducerParams.map(json_1.checkOrCloneParam);
+            var mapperObj = new (mapper.bind.apply(mapper, __spreadArray([void 0], mParams, false)))();
+            var reducerObj = new (reducer.bind.apply(reducer, __spreadArray([void 0], rParams, false)))();
+            Object.freeze(mapperObj);
+            Object.freeze(reducerObj);
+            if (!mapperObj.constructor.name) {
+                throw new Error("Mapper classes must be defined at top-level.");
+            }
+            if (!reducerObj.constructor.name) {
+                throw new Error("Reducer classes must be defined at top-level.");
+            }
+            var skmapper = _this.refs.binding.SkipRuntime_createMapper(_this.refs.handles.register(mapperObj));
+            if (std_1.sknative in reducerObj && typeof reducerObj[std_1.sknative] == "string") {
+                return _this.derive(_this.refs.binding.SkipRuntime_Collection__nativeMapReduce(_this.collection, skmapper, reducerObj[std_1.sknative]));
+            }
+            else {
+                var skreducer = _this.refs.binding.SkipRuntime_createReducer(_this.refs.handles.register(reducerObj), _this.refs.skjson.exportJSON(reducerObj.initial));
+                return _this.derive(_this.refs.binding.SkipRuntime_Collection__mapReduce(_this.collection, skmapper, skreducer));
+            }
+        };
+    };
+    EagerCollectionImpl.prototype.reduce = function (reducer) {
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        var reducerParams = params.map(json_1.checkOrCloneParam);
+        var reducerObj = new (reducer.bind.apply(reducer, __spreadArray([void 0], reducerParams, false)))();
+        Object.freeze(reducerObj);
+        if (!reducerObj.constructor.name) {
+            throw new Error("Reducer classes must be defined at top-level.");
+        }
+        if (std_1.sknative in reducerObj && typeof reducerObj[std_1.sknative] == "string") {
+            return this.derive(this.refs.binding.SkipRuntime_Collection__nativeReduce(this.collection, reducerObj[std_1.sknative]));
+        }
+        else {
+            var skreducer = this.refs.binding.SkipRuntime_createReducer(this.refs.handles.register(reducerObj), this.refs.skjson.exportJSON(reducerObj.initial));
+            return this.derive(this.refs.binding.SkipRuntime_Collection__reduce(this.collection, skreducer));
+        }
+    };
+    EagerCollectionImpl.prototype.merge = function () {
+        var others = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            others[_i] = arguments[_i];
+        }
+        var otherNames = others.map(function (other) { return other.collection; });
+        var mapped = this.refs.binding.SkipRuntime_Collection__merge(this.collection, this.refs.skjson.exportJSON(otherNames));
+        return this.derive(mapped);
+    };
+    EagerCollectionImpl.prototype.derive = function (collection) {
+        return new EagerCollectionImpl(collection, this.refs);
+    };
+    return EagerCollectionImpl;
+}(json_1.SkManaged));
+var CollectionWriter = /** @class */ (function () {
+    function CollectionWriter(collection, refs) {
+        this.collection = collection;
+        this.refs = refs;
+    }
+    CollectionWriter.prototype.update = function (values, isInit) {
+        var _this = this;
+        var update_ = function () {
+            return _this.refs.binding.SkipRuntime_CollectionWriter__update(_this.collection, _this.refs.skjson.exportJSON(values), isInit);
+        };
+        if (this.refs.needGC()) {
+            this.refs.runWithGC(update_);
+        }
+        else {
+            update_();
+        }
+    };
+    CollectionWriter.prototype.loading = function () {
+        var _this = this;
+        var loading_ = function () {
+            return _this.refs.binding.SkipRuntime_CollectionWriter__loading(_this.collection);
+        };
+        if (this.refs.needGC())
+            this.refs.runWithGC(loading_);
+        else
+            loading_();
+    };
+    CollectionWriter.prototype.error = function (error) {
+        var _this = this;
+        var error_ = function () {
+            return _this.refs.binding.SkipRuntime_CollectionWriter__error(_this.collection, _this.refs.skjson.exportJSON(error));
+        };
+        if (this.refs.needGC())
+            this.refs.runWithGC(error_);
+        else
+            error_();
+    };
+    return CollectionWriter;
+}());
+var ContextImpl = /** @class */ (function (_super) {
+    __extends(ContextImpl, _super);
+    function ContextImpl(refs) {
+        var _this = _super.call(this) || this;
+        _this.refs = refs;
+        Object.freeze(_this);
+        return _this;
+    }
+    ContextImpl.prototype.createLazyCollection = function (compute) {
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        var mapperParams = params.map(json_1.checkOrCloneParam);
+        var computeObj = new (compute.bind.apply(compute, __spreadArray([void 0], mapperParams, false)))();
+        Object.freeze(computeObj);
+        if (!computeObj.constructor.name) {
+            throw new Error("LazyCompute classes must be defined at top-level.");
+        }
+        var skcompute = this.refs.binding.SkipRuntime_createLazyCompute(this.refs.handles.register(computeObj));
+        var lazyCollection = this.refs.binding.SkipRuntime_Context__createLazyCollection(skcompute);
+        return new LazyCollectionImpl(lazyCollection, this.refs);
+    };
+    ContextImpl.prototype.useExternalResource = function (resource) {
+        var _a;
+        var collection = this.refs.binding.SkipRuntime_Context__useExternalResource(resource.service, resource.identifier, this.refs.skjson.exportJSON((_a = resource.params) !== null && _a !== void 0 ? _a : {}));
+        return new EagerCollectionImpl(collection, this.refs);
+    };
+    ContextImpl.prototype.jsonExtract = function (value, pattern) {
+        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_Context__jsonExtract(this.refs.skjson.exportJSON(value), pattern));
+    };
+    return ContextImpl;
+}(json_1.SkManaged));
+var ServiceInstanceFactory = /** @class */ (function () {
+    function ServiceInstanceFactory(init) {
+        this.init = init;
+    }
+    ServiceInstanceFactory.prototype.initService = function (service) {
+        return this.init(service);
+    };
+    return ServiceInstanceFactory;
+}());
+exports.ServiceInstanceFactory = ServiceInstanceFactory;
+var AllChecker = /** @class */ (function () {
+    function AllChecker(service, executor, resource, params) {
+        this.service = service;
+        this.executor = executor;
+        this.resource = resource;
+        this.params = params;
+    }
+    AllChecker.prototype.check = function (request) {
+        var result = this.service.getAll(this.resource, this.params, request);
+        if (result.errors.length > 0) {
+            this.executor.reject(new Error(JSON.stringify(result.errors)));
+        }
+        else {
+            this.executor.resolve(result.payload);
+        }
+    };
+    return AllChecker;
+}());
+var OneChecker = /** @class */ (function () {
+    function OneChecker(service, executor, resource, params, key) {
+        this.service = service;
+        this.executor = executor;
+        this.resource = resource;
+        this.params = params;
+        this.key = key;
+    }
+    OneChecker.prototype.check = function (request) {
+        var result = this.service.getArray(this.resource, this.key, this.params, request);
+        if (result.errors.length > 0) {
+            this.executor.reject(new Error(JSON.stringify(result.errors)));
+        }
+        else {
+            this.executor.resolve(result.payload);
+        }
+    };
+    return OneChecker;
+}());
+/**
+ * A `ServiceInstance` is a running instance of a `SkipService`, providing access to its resources
+ * and operations to manage susbscriptions and the service itself.
+ */
+var ServiceInstance = /** @class */ (function () {
+    function ServiceInstance(refs) {
+        this.refs = refs;
+    }
+    /**
+     * Instantiate a resource with some parameters and client session authentication token
+     * @param identifier - The resource instance identifier
+     * @param resource - A resource name, which must correspond to a key in this `SkipService`'s `resources` field
+     * @param params - Resource parameters, which will be passed to the resource constructor specified in this `SkipService`'s `resources` field
+     */
+    ServiceInstance.prototype.instantiateResource = function (identifier, resource, params) {
+        var _this = this;
+        var errorHdl = this.refs.runWithGC(function () {
+            return _this.refs.binding.SkipRuntime_Runtime__createResource(identifier, resource, _this.refs.skjson.exportJSON(params));
+        });
+        if (errorHdl)
+            throw this.refs.handles.deleteHandle(errorHdl);
+    };
+    /**
+     * Creates if not exists and get all current values of specified resource
+     * @param resource - the resource name corresponding to a key in remotes field of SkipService
+     * @param params - the parameters of the resource used to build the resource with the corresponding constructor specified in remotes field of SkipService
+     * @returns The current values of the corresponding resource with reactive responce token to allow subscription
+     */
+    ServiceInstance.prototype.getAll = function (resource, params, request) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        var get_ = function () {
+            return _this.refs.skjson.importJSON(_this.refs.binding.SkipRuntime_Runtime__getAll(resource, _this.refs.skjson.exportJSON(params), request !== undefined
+                ? typeof request == "string"
+                    ? _this.refs.binding.SkipRuntime_createIdentifier(request)
+                    : _this.refs.binding.SkipRuntime_createChecker(_this.refs.handles.register(new AllChecker(_this, request, resource, params)))
+                : null), true);
+        };
+        var result = this.refs.needGC() ? this.refs.runWithGC(get_) : get_();
+        if (typeof result == "number")
+            throw this.refs.handles.deleteHandle(result);
+        return result;
+    };
+    /**
+     * Get the current value of a key in the specified resource instance, creating it if it doesn't already exist
+     * @param resource - A resource name, which must correspond to a key in this `SkipService`'s `resources` field
+     * @param key - A key to look up in the resource instance
+     * @param params - Resource parameters, passed to the resource constructor specified in this `SkipService`'s `resources` field
+     * @returns The current value(s) for this key in the specified resource instance
+     */
+    ServiceInstance.prototype.getArray = function (resource, key, params, request) {
+        var _this = this;
+        if (params === void 0) { params = {}; }
+        var get_ = function () {
+            return _this.refs.skjson.importJSON(_this.refs.binding.SkipRuntime_Runtime__getForKey(resource, _this.refs.skjson.exportJSON(params), _this.refs.skjson.exportJSON(key), request !== undefined
+                ? typeof request == "string"
+                    ? _this.refs.binding.SkipRuntime_createIdentifier(request)
+                    : _this.refs.binding.SkipRuntime_createChecker(_this.refs.handles.register(new OneChecker(_this, request, resource, params, key)))
+                : null), true);
+        };
+        var needGC = this.refs.needGC();
+        var result = needGC ? this.refs.runWithGC(get_) : get_();
+        if (typeof result == "number")
+            throw this.refs.handles.deleteHandle(result);
+        return result;
+    };
+    /**
+     * Close the specified resource instance
+     * @param resourceInstanceId - The resource identifier
+     */
+    ServiceInstance.prototype.closeResourceInstance = function (resourceInstanceId) {
+        var _this = this;
+        var errorHdl = this.refs.runWithGC(function () {
+            return _this.refs.binding.SkipRuntime_Runtime__closeResource(resourceInstanceId);
+        });
+        if (errorHdl)
+            throw this.refs.handles.deleteHandle(errorHdl);
+    };
+    /**
+     * Initiate reactive subscription on a resource instance
+     * @param resourceInstanceId - the resource instance identifier
+     * @param notifier - the object containing subscription callbacks
+     * @param notifier.subscribed - A callback to execute when subscription effectivly done
+     * @param notifier.notify - A callback to execute on collection updates
+     * @param notifier.close - A callback to execute on resource close
+     * @param watermark - the watermark where to start the subscription
+     * @returns A subcription identifier
+     */
+    ServiceInstance.prototype.subscribe = function (resourceInstanceId, notifier, watermark) {
+        var _this = this;
+        var session = this.refs.runWithGC(function () {
+            var sknotifier = _this.refs.binding.SkipRuntime_createNotifier(_this.refs.handles.register(notifier));
+            return _this.refs.binding.SkipRuntime_Runtime__subscribe(resourceInstanceId, sknotifier, watermark !== null && watermark !== void 0 ? watermark : null);
+        });
+        if (session == -1n) {
+            throw new errors_js_1.UnknownCollectionError("Unknown resource instance '".concat(resourceInstanceId, "'"));
+        }
+        else if (session < 0n) {
+            throw new Error("Unknown error");
+        }
+        return session;
+    };
+    /**
+     * Terminate a client's subscription to a reactive resource instance
+     * @param id - The subcription identifier returned by a call to `subscribe`
+     */
+    ServiceInstance.prototype.unsubscribe = function (id) {
+        var _this = this;
+        var errorHdl = this.refs.runWithGC(function () {
+            return _this.refs.binding.SkipRuntime_Runtime__unsubscribe(id);
+        });
+        if (errorHdl) {
+            throw this.refs.handles.deleteHandle(errorHdl);
+        }
+    };
+    /**
+     * Update an input collection
+     * @param collection - the name of the input collection to update
+     * @param entries - entries to update in the collection.
+     */
+    ServiceInstance.prototype.update = function (collection, entries) {
+        var _this = this;
+        var errorHdl = this.refs.runWithGC(function () {
+            return _this.refs.binding.SkipRuntime_Runtime__update(collection, _this.refs.skjson.exportJSON(entries));
+        });
+        if (errorHdl) {
+            throw this.refs.handles.deleteHandle(errorHdl);
+        }
+    };
+    /**
+     * Close all resources and shut down the service.
+     * Any subsequent calls on the service will result in errors.
+     */
+    ServiceInstance.prototype.close = function () {
+        var _this = this;
+        var errorHdl = this.refs.runWithGC(function () {
+            return _this.refs.binding.SkipRuntime_closeService();
+        });
+        if (errorHdl) {
+            throw this.refs.handles.deleteHandle(errorHdl);
+        }
+    };
+    return ServiceInstance;
+}());
+exports.ServiceInstance = ServiceInstance;
+var ValuesImpl = /** @class */ (function () {
+    function ValuesImpl(skjson, binding, pointer) {
+        var _this = this;
+        this.skjson = skjson;
+        this.binding = binding;
+        this.pointer = pointer;
+        this.toArray = function () {
+            return Array.from(_this);
+        };
+        this.skjson = skjson;
+        this.binding = binding;
+        this.pointer = pointer;
+    }
+    ValuesImpl.prototype.next = function () {
+        return this.skjson.importOptJSON(this.binding.SkipRuntime_NonEmptyIterator__next(this.pointer));
+    };
+    ValuesImpl.prototype.getUnique = function () {
+        var value = this.skjson.importOptJSON(this.binding.SkipRuntime_NonEmptyIterator__uniqueValue(this.pointer));
+        if (value == null)
+            throw new api_1.NonUniqueValueException();
+        return value;
+    };
+    ValuesImpl.prototype[Symbol.iterator] = function () {
+        var cloned_iter = new ValuesImpl(this.skjson, this.binding, this.binding.SkipRuntime_NonEmptyIterator__clone(this.pointer));
+        return {
+            next: function () {
+                var value = cloned_iter.next();
+                return { value: value, done: value == null };
+            },
+        };
+    };
+    return ValuesImpl;
+}());
+var ToBinding = /** @class */ (function () {
+    function ToBinding(binding, runWithGC, getConverter, getError) {
+        this.binding = binding;
+        this.runWithGC = runWithGC;
+        this.getConverter = getConverter;
+        this.getError = getError;
+        this.stack = new Stack();
+        this.handles = new Handles();
+    }
+    ToBinding.prototype.register = function (v) {
+        return this.handles.register(v);
+    };
+    ToBinding.prototype.deleteHandle = function (id) {
+        return this.handles.deleteHandle(id);
+    };
+    ToBinding.prototype.SkipRuntime_getErrorHdl = function (exn) {
+        return this.handles.register(this.getError(exn));
+    };
+    ToBinding.prototype.SkipRuntime_pushContext = function (context) {
+        this.stack.push(context);
+    };
+    ToBinding.prototype.SkipRuntime_popContext = function () {
+        this.stack.pop();
+    };
+    ToBinding.prototype.SkipRuntime_getContext = function () {
+        return this.stack.get();
+    };
+    // Mapper
+    ToBinding.prototype.SkipRuntime_Mapper__mapEntry = function (skmapper, key, values) {
+        var skjson = this.getJsonConverter();
+        var mapper = this.handles.get(skmapper);
+        var result = mapper.mapEntry(skjson.importJSON(key), new ValuesImpl(skjson, this.binding, values));
+        return skjson.exportJSON(Array.from(result));
+    };
+    ToBinding.prototype.SkipRuntime_deleteMapper = function (mapper) {
+        this.handles.deleteHandle(mapper);
+    };
+    // LazyCompute
+    ToBinding.prototype.SkipRuntime_LazyCompute__compute = function (sklazyCompute, self, skkey) {
+        var skjson = this.getJsonConverter();
+        var lazyCompute = this.handles.get(sklazyCompute);
+        var result = lazyCompute.compute(new LazyCollectionImpl(self, this.refs()), skjson.importJSON(skkey));
+        return skjson.exportJSON(Array.from(result));
+    };
+    ToBinding.prototype.SkipRuntime_deleteLazyCompute = function (lazyCompute) {
+        this.handles.deleteHandle(lazyCompute);
+    };
+    // Resource
+    ToBinding.prototype.SkipRuntime_Resource__instantiate = function (skresource, skcollections) {
+        var skjson = this.getJsonConverter();
+        var resource = this.handles.get(skresource);
+        var collections = {};
+        var keysIds = skjson.importJSON(skcollections);
+        var refs = this.refs();
+        for (var _i = 0, _a = Object.entries(keysIds); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], name_1 = _b[1];
+            collections[key] = new EagerCollectionImpl(name_1, refs);
+        }
+        var collection = resource.instantiate(collections, new ContextImpl(refs));
+        return collection.collection;
+    };
+    ToBinding.prototype.SkipRuntime_deleteResource = function (resource) {
+        this.handles.deleteHandle(resource);
+    };
+    // ResourceBuilder
+    ToBinding.prototype.SkipRuntime_ResourceBuilder__build = function (skbuilder, skparams) {
+        var skjson = this.getJsonConverter();
+        var builder = this.handles.get(skbuilder);
+        var resource = builder.build(skjson.importJSON(skparams));
+        return this.binding.SkipRuntime_createResource(this.handles.register(resource));
+    };
+    ToBinding.prototype.SkipRuntime_deleteResourceBuilder = function (builder) {
+        this.handles.deleteHandle(builder);
+    };
+    // Service
+    ToBinding.prototype.SkipRuntime_Service__createGraph = function (skservice, skcollections) {
+        var skjson = this.getJsonConverter();
+        var service = this.handles.get(skservice);
+        var collections = {};
+        var keysIds = skjson.importJSON(skcollections);
+        var refs = this.refs();
+        for (var _i = 0, _a = Object.entries(keysIds); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], name_2 = _b[1];
+            collections[key] = new EagerCollectionImpl(name_2, refs);
+        }
+        var result = service.createGraph(collections, new ContextImpl(refs));
+        var collectionsNames = {};
+        for (var _c = 0, _d = Object.entries(result); _c < _d.length; _c++) {
+            var _e = _d[_c], name_3 = _e[0], collection = _e[1];
+            collectionsNames[name_3] = collection.collection;
+        }
+        return skjson.exportJSON(collectionsNames);
+    };
+    ToBinding.prototype.SkipRuntime_deleteService = function (service) {
+        this.handles.deleteHandle(service);
+    };
+    // Notifier
+    ToBinding.prototype.SkipRuntime_Notifier__subscribed = function (sknotifier) {
+        var notifier = this.handles.get(sknotifier);
+        notifier.subscribed();
+    };
+    ToBinding.prototype.SkipRuntime_Notifier__notify = function (sknotifier, skvalues, watermark, isUpdates) {
+        var skjson = this.getJsonConverter();
+        var notifier = this.handles.get(sknotifier);
+        var values = skjson.importJSON(skvalues, true);
+        var isInitial = isUpdates ? false : true;
+        notifier.notify({
+            values: values,
+            watermark: watermark,
+            isInitial: isInitial,
+        });
+    };
+    ToBinding.prototype.SkipRuntime_Notifier__close = function (sknotifier) {
+        var notifier = this.handles.get(sknotifier);
+        notifier.close();
+    };
+    ToBinding.prototype.SkipRuntime_deleteNotifier = function (notifier) {
+        this.handles.deleteHandle(notifier);
+    };
+    // Reducer
+    ToBinding.prototype.SkipRuntime_Reducer__add = function (skreducer, skacc, skvalue) {
+        var skjson = this.getJsonConverter();
+        var reducer = this.handles.get(skreducer);
+        return skjson.exportJSON(reducer.add(skacc ? skjson.importJSON(skacc) : null, skjson.importJSON(skvalue)));
+    };
+    ToBinding.prototype.SkipRuntime_Reducer__remove = function (skreducer, skacc, skvalue) {
+        var skjson = this.getJsonConverter();
+        var reducer = this.handles.get(skreducer);
+        return skjson.exportJSON(reducer.remove(skjson.importJSON(skacc), skjson.importJSON(skvalue)));
+    };
+    ToBinding.prototype.SkipRuntime_deleteReducer = function (reducer) {
+        this.handles.deleteHandle(reducer);
+    };
+    // ExternalService
+    ToBinding.prototype.SkipRuntime_ExternalService__subscribe = function (sksupplier, writerId, resource, skparams) {
+        var skjson = this.getJsonConverter();
+        var supplier = this.handles.get(sksupplier);
+        var writer = new CollectionWriter(writerId, this.refs());
+        var params = skjson.importJSON(skparams, true);
+        supplier.subscribe(resource, params, {
+            update: writer.update.bind(writer),
+            error: writer.error.bind(writer),
+            loading: writer.loading.bind(writer),
+        });
+    };
+    ToBinding.prototype.SkipRuntime_ExternalService__unsubscribe = function (sksupplier, resource, skparams) {
+        var skjson = this.getJsonConverter();
+        var supplier = this.handles.get(sksupplier);
+        var params = skjson.importJSON(skparams, true);
+        supplier.unsubscribe(resource, params);
+    };
+    ToBinding.prototype.SkipRuntime_ExternalService__shutdown = function (sksupplier) {
+        var supplier = this.handles.get(sksupplier);
+        supplier.shutdown();
+    };
+    ToBinding.prototype.SkipRuntime_deleteExternalService = function (supplier) {
+        this.handles.deleteHandle(supplier);
+    };
+    // Checker
+    ToBinding.prototype.SkipRuntime_Checker__check = function (skchecker, request) {
+        var checker = this.handles.get(skchecker);
+        checker.check(request);
+    };
+    ToBinding.prototype.SkipRuntime_deleteChecker = function (checker) {
+        this.handles.deleteHandle(checker);
+    };
+    ToBinding.prototype.initService = function (service) {
+        var refs = this.refs();
+        var errorHdl = refs.runWithGC(function () {
+            var _a;
+            var skExternalServices = refs.binding.SkipRuntime_ExternalServiceMap__create();
+            if (service.externalServices) {
+                for (var _i = 0, _b = Object.entries(service.externalServices); _i < _b.length; _i++) {
+                    var _c = _b[_i], name_4 = _c[0], remote = _c[1];
+                    var skremote = refs.binding.SkipRuntime_createExternalService(refs.handles.register(remote));
+                    refs.binding.SkipRuntime_ExternalServiceMap__add(skExternalServices, name_4, skremote);
+                }
+            }
+            var skresources = refs.binding.SkipRuntime_ResourceBuilderMap__create();
+            for (var _d = 0, _e = Object.entries(service.resources); _d < _e.length; _d++) {
+                var _f = _e[_d], name_5 = _f[0], builder = _f[1];
+                var skbuilder = refs.binding.SkipRuntime_createResourceBuilder(refs.handles.register(new binding_js_1.ResourceBuilder(builder)));
+                refs.binding.SkipRuntime_ResourceBuilderMap__add(skresources, name_5, skbuilder);
+            }
+            var skservice = refs.binding.SkipRuntime_createService(refs.handles.register(service), refs.skjson.exportJSON((_a = service.initialData) !== null && _a !== void 0 ? _a : {}), skresources, skExternalServices);
+            return refs.binding.SkipRuntime_initService(skservice);
+        });
+        if (errorHdl)
+            throw refs.handles.deleteHandle(errorHdl);
+        return new ServiceInstance(refs);
+    };
+    //
+    ToBinding.prototype.getJsonConverter = function () {
+        if (this.skjson == undefined) {
+            this.skjson = this.getConverter();
+        }
+        return this.skjson;
+    };
+    ToBinding.prototype.needGC = function () {
+        return this.SkipRuntime_getContext() == null;
+    };
+    ToBinding.prototype.refs = function () {
+        return new Refs(this.binding, this.getConverter(), this.handles, this.needGC.bind(this), this.runWithGC);
+    };
+    return ToBinding;
+}());
+exports.ToBinding = ToBinding;