# HG changeset patch
# User cin
# Date 1530030944 -10800
# Node ID acdcdf1a8d2161228f603ce32f20e302f3626af8
# Parent d796bbbe558c049972d8527c594677316433dfdd
repository reorganized
diff -r d796bbbe558c -r acdcdf1a8d21 .hgignore
--- a/.hgignore Sat Jun 23 21:50:11 2018 +0300
+++ b/.hgignore Tue Jun 26 19:35:44 2018 +0300
@@ -1,2 +1,5 @@
.git/
.gitignore/
+syntax: glob
+core/build/
+.gradle/
diff -r d796bbbe558c -r acdcdf1a8d21 .project
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/.project Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,17 @@
+
+
+ implab
+ Project implab created by Buildship.
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectbuilder
+
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectnature
+
+
diff -r d796bbbe558c -r acdcdf1a8d21 .settings/org.eclipse.buildship.core.prefs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/.settings/org.eclipse.buildship.core.prefs Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,2 @@
+connection.project.dir=
+eclipse.preferences.version=1
diff -r d796bbbe558c -r acdcdf1a8d21 core/.project
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/.project Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,17 @@
+
+
+ core
+ Project core created by Buildship.
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectbuilder
+
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectnature
+
+
diff -r d796bbbe558c -r acdcdf1a8d21 core/.settings/org.eclipse.buildship.core.prefs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/.settings/org.eclipse.buildship.core.prefs Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,2 @@
+connection.project.dir=..
+eclipse.preferences.version=1
diff -r d796bbbe558c -r acdcdf1a8d21 core/build.gradle
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/build.gradle Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,19 @@
+
+println "version: $version"
+
+task prepare(type: Copy) {
+ from('src')
+ from('.') {
+ include 'readme.md', 'license', 'history.md', 'package.json'
+ }
+ into(buildDir)
+}
+
+task build(dependsOn: prepare) {
+}
+
+task pack(dependsOn: build, type: Exec) {
+ workingDir = buildDir
+
+ commandLine 'npm', 'pack'
+}
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/history.md
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/history.md Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,12 @@
+HISTORY
+=======
+
+1.0.1
+-----
+
+First release, intorduces the followinf features
+
+- `di` - dependency injection conyainer
+- `log` - log4 style logging system
+- `text` - simple and fast text templating and formatting
+- `Uuid` - uuid generation traits
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/license
diff -r d796bbbe558c -r acdcdf1a8d21 core/package.json
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/package.json Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,18 @@
+{
+ "name": "@implab/core",
+ "version": "1.0.1",
+ "description": "Dependency injection, logging, simple and fast text template engine",
+ "main": "main.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": [
+ "di",
+ "ioc",
+ "logging",
+ "template engine",
+ "dependency injection"
+ ],
+ "author": "Sergey Smirnov",
+ "license": "MIT"
+}
diff -r d796bbbe558c -r acdcdf1a8d21 core/readme.md
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/Deferred.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/Deferred.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,3 @@
+define(["dojo/Deferred"], function(Deferred) {
+ return Deferred;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/Uri.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/Uri.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,232 @@
+define(
+ [ "./declare" ],
+ function(declare) {
+ function parseURI(uri) {
+ var schema, host, port, path, query, hash, i;
+ if (typeof (uri) == "string") {
+ if ((i = uri.indexOf(":")) >= 0 &&
+ uri.substr(0, i).match(/^\w+$/)) {
+ schema = uri.substr(0, i);
+ uri = uri.substr(i + 1);
+ }
+
+ if (uri.indexOf("//") === 0) {
+ uri = uri.substr(2);
+ if ((i = uri.indexOf("/")) >= 0) {
+ host = uri.substr(0, i);
+ uri = uri.substr(i);
+ } else {
+ host = uri;
+ uri = "";
+ }
+ }
+
+ if ((i = uri.indexOf("?")) >= 0) {
+ path = uri.substr(0, i);
+ uri = uri.substr(i + 1);
+
+ } else {
+ path = uri;
+ uri = "";
+
+ if ((i = path.indexOf("#")) >= 0) {
+ hash = path.substr(i + 1);
+ path = path.substr(0, i);
+ }
+ }
+
+ if ((i = uri.indexOf("#")) >= 0) {
+ query = uri.substr(0, i);
+ hash = uri.substr(i + 1);
+ } else {
+ query = uri;
+ }
+ }
+
+ if (host && (i = host.lastIndexOf(":")) >= 0) {
+ port = host.substr(i + 1);
+ host = host.substr(0, i);
+ }
+
+ return {
+ schema : schema,
+ host : host,
+ port : port,
+ path : path,
+ query : query,
+ hash : hash
+ };
+ }
+
+ function makeURI(options) {
+ var uri = [];
+
+ if (options.schema)
+ uri.push(options.schema, ":");
+ if (options.host)
+ uri.push("//", options.host);
+ if (options.host && options.port)
+ uri.push(":", options.port);
+
+ if (options.path) {
+ if (options.host && options.path[0] != "/")
+ uri.push("/");
+ uri.push(options.path);
+ } else if (options.host) {
+ uri.push("/");
+ }
+
+ if (options.query)
+ uri.push("?", options.query);
+ if (options.hash)
+ uri.push("#", options.hash);
+
+ return uri.join("");
+ }
+
+ function reducePath(parts) {
+ var balance = 0, result = [], isRoot;
+
+ for (var i = 0; i < parts.length; i++) {
+ var part = parts[i];
+ switch (part) {
+ case "..":
+ if (balance > 0) {
+ result.pop();
+ } else {
+ if (isRoot)
+ throw new Error("Unbalanced path: " + parts);
+
+ result.push(part);
+ }
+ balance--;
+ break;
+ case ".":
+ break;
+ case "":
+ if (i === 0) {
+ isRoot = true;
+ result.push(part);
+ }
+ break;
+ default:
+ result.push(part);
+ balance++;
+ break;
+ }
+ }
+
+ return result.join("/");
+ }
+
+ var meta = {
+ schema : null,
+ host : null,
+ port : null,
+ path : null,
+ query : null,
+ hash : null
+ };
+
+ var URI = declare(null, {
+ constructor : function(opts) {
+ if (typeof (opts) == "string")
+ opts = parseURI(opts);
+ for ( var p in meta)
+ if (p in opts)
+ this[p] = opts[p];
+ },
+
+ clone : function() {
+ return new URI(this);
+ },
+
+ combine : function(rel) {
+ var me = this;
+
+ if (typeof (rel) === "string")
+ rel = new URI(rel);
+ else
+ rel = rel.clone();
+
+ // //some.host:123/path?q=a#123
+ if (rel.host)
+ return rel;
+
+ // /abs/path?q=a#123
+ if (rel.path && rel.path[0] == "/") {
+ if (me.host) {
+ rel.schema = me.schema;
+ rel.host = me.host;
+ rel.port = me.port;
+ }
+ return rel;
+ }
+
+ var base = me.clone();
+
+ // rel/path?a=b#cd
+ if (rel.path) {
+ var segments = base.getSegments();
+ segments.pop();
+ segments.push.apply(segments, rel.getSegments());
+
+ base.path = reducePath(segments);
+ }
+
+ // ?q=a#123
+ if (rel.query)
+ base.query = rel.query;
+ if (rel.hash)
+ base.hase = rel.hash;
+
+ return base;
+ },
+
+ optimize : function() {
+ this.path = reducePath(this.getSegments());
+ },
+
+ getSegments : function() {
+ if (typeof (this.path) === "string")
+ return this.path.split("/");
+ else
+ return [];
+ },
+
+ toString : function() {
+ var uri = [], me = this;
+
+ if (me.schema)
+ uri.push(me.schema, ":");
+ if (me.host)
+ uri.push("//", me.host);
+ if (me.host && me.port)
+ uri.push(":", me.port);
+
+ if (me.path) {
+ if (me.host && me.path[0] != "/")
+ uri.push("/");
+ uri.push(me.path);
+ } else if (me.host) {
+ uri.push("/");
+ }
+
+ if (me.query)
+ uri.push("?", me.query);
+ if (me.hash)
+ uri.push("#", me.hash);
+
+ return uri.join("");
+ }
+
+ });
+
+ URI.combine = function(base, rel) {
+ if (typeof (base) === "string")
+ base = new URI(base);
+ return base.combine(rel).toString();
+ };
+
+ return URI;
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/Uuid.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/Uuid.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,278 @@
+// uuid.js
+//
+// Copyright (c) 2010-2012 Robert Kieffer
+// MIT License - http://opensource.org/licenses/mit-license.php
+define([], function () {
+ 'use strict';
+
+ var _window = 'undefined' !== typeof window ? window : null;
+
+ // Unique ID creation requires a high quality random # generator. We
+ // feature
+ // detect to determine the best RNG source, normalizing to a function
+ // that
+ // returns 128-bits of randomness, since that's what's usually required
+ var _rng, _mathRNG, _nodeRNG, _whatwgRNG, _previousRoot;
+
+ function setupBrowser() {
+ // Allow for MSIE11 msCrypto
+ var _crypto = _window.crypto || _window.msCrypto;
+
+ if (!_rng && _crypto && _crypto.getRandomValues) {
+ // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
+ //
+ // Moderately fast, high quality
+ try {
+ var _rnds8 = new Uint8Array(16);
+ _whatwgRNG = _rng = function whatwgRNG() {
+ _crypto.getRandomValues(_rnds8);
+ return _rnds8;
+ };
+ _rng();
+ } catch (e) { /**/ }
+ }
+
+ if (!_rng) {
+ // Math.random()-based (RNG)
+ //
+ // If all else fails, use Math.random(). It's fast, but is of
+ // unspecified
+ // quality.
+ var _rnds = new Array(16);
+ _mathRNG = _rng = function () {
+ for (var i = 0, r; i < 16; i++) {
+ if ((i & 0x03) === 0) {
+ r = Math.random() * 0x100000000;
+ }
+ _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
+ }
+
+ return _rnds;
+ };
+ if ('undefined' !== typeof console && console.warn) {
+ console
+ .warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
+ }
+ }
+ }
+
+ function setupNode() {
+ // Node.js crypto-based RNG -
+ // http://nodejs.org/docs/v0.6.2/api/crypto.html
+ //
+ // Moderately fast, high quality
+ if ('function' === typeof require) {
+ try {
+ var _rb = require('crypto').randomBytes;
+ _nodeRNG = _rng = _rb && function () {
+ return _rb(16);
+ };
+ _rng();
+ } catch (e) { /**/ }
+ }
+ }
+
+ if (_window) {
+ setupBrowser();
+ } else {
+ setupNode();
+ }
+
+ // Buffer class to use
+ var BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
+
+ // Maps for number <-> hex string conversion
+ var _byteToHex = [];
+ var _hexToByte = {};
+ for (var i = 0; i < 256; i++) {
+ _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+ _hexToByte[_byteToHex[i]] = i;
+ }
+
+ // **`parse()` - Parse a UUID into it's component bytes**
+ function parse(s, buf, offset) {
+ var i = (buf && offset) || 0,
+ ii = 0;
+
+ buf = buf || [];
+ s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
+ if (ii < 16) { // Don't overflow!
+ buf[i + ii++] = _hexToByte[oct];
+ }
+ });
+
+ // Zero out remaining bytes if string was short
+ while (ii < 16) {
+ buf[i + ii++] = 0;
+ }
+
+ return buf;
+ }
+
+ // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
+ function unparse(buf, offset) {
+ var i = offset || 0,
+ bth = _byteToHex;
+ return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' + bth[buf[i++]] +
+ bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
+ }
+
+ // **`v1()` - Generate time-based UUID**
+ //
+ // Inspired by https://github.com/LiosK/UUID.js
+ // and http://docs.python.org/library/uuid.html
+
+ // random #'s we need to init node and clockseq
+ var _seedBytes = _rng();
+
+ // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
+ // 1)
+ var _nodeId = [
+ _seedBytes[0] | 0x01,
+ _seedBytes[1],
+ _seedBytes[2],
+ _seedBytes[3],
+ _seedBytes[4],
+ _seedBytes[5]
+ ];
+
+ // Per 4.2.2, randomize (14 bit) clockseq
+ var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
+
+ // Previous uuid creation time
+ var _lastMSecs = 0,
+ _lastNSecs = 0;
+
+ // See https://github.com/broofa/node-uuid for API details
+ function v1(options, buf, offset) {
+ var i = buf && offset || 0;
+ var b = buf || [];
+
+ options = options || {};
+
+ var clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
+
+ // UUID timestamps are 100 nano-second units since the Gregorian
+ // epoch,
+ // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
+ // time is handled internally as 'msecs' (integer milliseconds) and
+ // 'nsecs'
+ // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
+ // 00:00.
+ var msecs = (options.msecs != null) ? options.msecs : new Date()
+ .getTime();
+
+ // Per 4.2.1.2, use count of uuid's generated during the current
+ // clock
+ // cycle to simulate higher resolution clock
+ var nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
+
+ // Time since last uuid creation (in msecs)
+ var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
+
+ // Per 4.2.1.2, Bump clockseq on clock regression
+ if (dt < 0 && options.clockseq == null) {
+ clockseq = clockseq + 1 & 0x3fff;
+ }
+
+ // Reset nsecs if clock regresses (new clockseq) or we've moved onto
+ // a new
+ // time interval
+ if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
+ nsecs = 0;
+ }
+
+ // Per 4.2.1.2 Throw error if too many uuids are requested
+ if (nsecs >= 10000) {
+ throw new Error(
+ 'uuid.v1(): Can\'t create more than 10M uuids/sec');
+ }
+
+ _lastMSecs = msecs;
+ _lastNSecs = nsecs;
+ _clockseq = clockseq;
+
+ // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+ msecs += 12219292800000;
+
+ // `time_low`
+ var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+ b[i++] = tl >>> 24 & 0xff;
+ b[i++] = tl >>> 16 & 0xff;
+ b[i++] = tl >>> 8 & 0xff;
+ b[i++] = tl & 0xff;
+
+ // `time_mid`
+ var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+ b[i++] = tmh >>> 8 & 0xff;
+ b[i++] = tmh & 0xff;
+
+ // `time_high_and_version`
+ b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+ b[i++] = tmh >>> 16 & 0xff;
+
+ // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+ b[i++] = clockseq >>> 8 | 0x80;
+
+ // `clock_seq_low`
+ b[i++] = clockseq & 0xff;
+
+ // `node`
+ var node = options.node || _nodeId;
+ for (var n = 0; n < 6; n++) {
+ b[i + n] = node[n];
+ }
+
+ return buf ? buf : unparse(b);
+ }
+
+ // **`v4()` - Generate random UUID**
+
+ // See https://github.com/broofa/node-uuid for API details
+ function v4(options, buf, offset) {
+ // Deprecated - 'format' argument, as supported in v1.2
+ var i = buf && offset || 0;
+
+ if (typeof (options) === 'string') {
+ buf = (options === 'binary') ? new BufferClass(16) : null;
+ options = null;
+ }
+ options = options || {};
+
+ var rnds = options.random || (options.rng || _rng)();
+
+ // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+ rnds[6] = (rnds[6] & 0x0f) | 0x40;
+ rnds[8] = (rnds[8] & 0x3f) | 0x80;
+
+ // Copy bytes to buffer, if provided
+ if (buf) {
+ for (var ii = 0; ii < 16; ii++) {
+ buf[i + ii] = rnds[ii];
+ }
+ }
+
+ return buf || unparse(rnds);
+ }
+
+ // Export public API
+ var uuid = function () {
+ return new String(v4());
+ };
+ uuid.v1 = v1;
+ uuid.v4 = v4;
+ uuid.create = v4;
+ uuid.empty = "00000000-0000-0000-0000-000000000000";
+ uuid.parse = parse;
+ uuid.unparse = unparse;
+ uuid.BufferClass = BufferClass;
+ uuid._rng = _rng;
+ uuid._mathRNG = _mathRNG;
+ uuid._nodeRNG = _nodeRNG;
+ uuid._whatwgRNG = _whatwgRNG;
+
+ return uuid;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/components/ActivationController.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/components/ActivationController.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,120 @@
+define(["dojo/_base/declare", "../guard", "../safe", "../log/_LogMixin"], function (declare, guard, safe, _LogMixin) {
+ "use strict";
+ return declare([_LogMixin], {
+
+ _current: null,
+
+ _pending: false,
+
+ getCurrent: function () {
+ return this._current;
+ },
+
+ _start: function () {
+ if (this._pending)
+ throw new Error("The activation/decativation is already pending");
+ this._pending = true;
+ },
+
+ _await: function (d) {
+ var me = this;
+ return d.then(function (x) {
+ me._pending = false;
+ return x;
+ }, function (e) {
+ me._pending = false;
+ throw e;
+ });
+ },
+
+ activate: function (component) {
+ safe.argumentNotNull(component, "component");
+ var me = this;
+ if (component.getController() !== this)
+ throw new Error("The specified component doesn't belong to this controller");
+
+ return me._await(guard(me, "_start").then(function () {
+ me._activate(component);
+ }));
+ },
+
+ _activate: function (component) {
+ var me = this;
+ if (me._current === component)
+ return guard(false);
+
+ // before activation hook
+ return guard(me, "onActivating", [component]).then(function () {
+ // deactivate curent
+ if (me._current)
+ return me._current.deactivate(true).then(function () {
+ try {
+ me._current.onDeactivated();
+ } catch (err) {
+ me.error(err);
+ }
+ // HACK raise deactivated event
+ try {
+ me.onDeactivated(me._current, component);
+ } catch (err) {
+ // deactivated shouldn't affect the process
+ me.error(err);
+ }
+ me._current = null;
+
+ });
+ }).then(function () {
+ return component.activate(true);
+ }).then(function () {
+ me._current = component;
+ try {
+ me.onActivated(component);
+ } catch (err) {
+ me.error(err);
+ }
+
+ });
+
+ },
+
+ /**
+ * Деактивирует текущую компоненту.
+ *
+ * @async
+ * @returns true - компонента была деактивирована, либо нет активной
+ * компоненты. false - запрос на деактивацию - отклонен.
+ */
+ deactivate: function () {
+ var me = this;
+ return me._await(guard(me, "_start").then(function () {
+ return me._deactivate();
+ }));
+ },
+
+ _deactivate: function () {
+ var me = this;
+ if (!me._current)
+ return guard(false);
+
+ return guard(me, "onDeactivating").then(function () {
+ return me._current.deactivate(true);
+ }).then(function () {
+ // HACK raise deactivated event
+ try {
+ me.onDeactivated(me._current);
+ } catch (err) {
+ me.error(err);
+ }
+ me._current = null;
+ });
+ },
+
+ onActivating: function (component) {},
+
+ onDeactivating: function (component) {},
+
+ onDeactivated: function (component, next) {},
+
+ onActivated: function (component) {}
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/components/StateMachine.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/components/StateMachine.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,34 @@
+define([ "dojo/_base/declare", "../safe", "../text/format" ], function(declare, safe, format) {
+ return declare(null, {
+ states : null,
+
+ current : null,
+
+ constructor : function(opts) {
+ safe.argumentNotNull(opts, "opts");
+ safe.argumentNotNull(opts.states, "opts.states");
+ safe.argumentNotNull(opts.initial, "opts.initial");
+
+ this.states = opts.states;
+ this.current = opts.initial;
+
+ if (safe.isNull(this.states[this.current]))
+ throw new Error("Invalid initial state " + this.current);
+ },
+
+ move : function(input, noThrow) {
+ safe.argumentNotNull(input, "input");
+
+ var next = this.states[this.current][input];
+ if(safe.isNull(next)) {
+ if (noThrow)
+ return false;
+ else
+ throw new Error(format("Invalid transition {0}-{1}->?", this.current, input));
+ } else {
+ this.current = next;
+ return true;
+ }
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/components/_ActivatableMixin.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/components/_ActivatableMixin.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,153 @@
+define(["dojo/_base/declare", "../guard", "./StateMachine", "../log/_LogMixin", ], function (declare, guard, StateMachine, _LogMixin) {
+
+ var states = {
+ inactive: {
+ activate: "activating"
+ },
+ activating: {
+ success: "active",
+ failed: "inactive"
+ },
+ active: {
+ deactivate: "deactivating"
+ },
+ deactivating: {
+ success: "inactive",
+ failed: "active"
+ }
+ };
+
+ return declare([_LogMixin], {
+ _controller: null,
+
+ _active: null,
+
+ constructor: function () {
+ this._active = new StateMachine({
+ states: states,
+ initial: "inactive"
+ });
+ },
+
+ /**
+ * @returns {Object} контроллер для активации текущей компоненты
+ */
+ getController: function () {
+ return this._controller;
+ },
+
+ /**
+ * @param {Object}
+ * v Контроллер для активации текущей компоненты
+ */
+ setController: function (v) {
+ this._controller = v;
+ },
+
+ /**
+ * @returns {Boolean} текущая компонента активна
+ */
+ isActive: function () {
+ return this._active.current == "active";
+ },
+
+ assertActive: function () {
+ if (!this.isActive())
+ throw new Error("The object must be active to perform the operation");
+ },
+
+ /**
+ * Активирует текущую компоненту, если у текущей компоненты задан
+ * контроллер, то активация будет осуществляться через него
+ *
+ * @async
+ * @param{Boolean}
+ * direct вызов должен осуществится напрямую, без участия
+ * контроллера.
+ * @return{Boolean} успешно/неуспешно
+ */
+ activate: function (direct) {
+ var me = this;
+ if (!direct && this._controller)
+ return me._controller.activate(me).then(function () {
+ me.onActivated();
+ });
+
+ me._active.move("activate");
+ return guard(me, "onActivating").then(function () {
+ me.log("Activated");
+ me._active.move("success");
+ if (!me._controller)
+ me.onActivated();
+ }, function (err) {
+ console.error(err);
+ me.error("Activation failed: {0}", err);
+ me._active.move("failed");
+ throw err;
+ });
+ },
+
+ /**
+ * Деактивирует текущую компоненту, если у компоненты задан контроллер,
+ * то деактивация будет осуществляться через него.
+ *
+ * @async
+ * @param{Boolean} direct вызов должен осуществится напрямую, без
+ * участия контроллера.
+ *
+ */
+ deactivate: function (direct) {
+ var me = this;
+ if (!direct && me._controller)
+ return me._controller.deactivate(me).then(function () {
+ me.onDeactivated();
+ });
+
+ me._active.move("deactivate");
+ return guard(me, "onDeactivating").then(function () {
+ me.log("Deactivated");
+ me._active.move("success");
+ if (!me._controller)
+ me.onDeactivated();
+ }, function (err) {
+ console.error(err);
+ me.error("Deactivation failed: {0}", err);
+ me.move("failed");
+ throw err;
+ });
+
+ },
+
+ toogleActive: function () {
+ var me = this;
+ return (me.isActive() ? me.deactivate() : me.activate()).then(function () {
+ return me.isActive();
+ });
+ },
+
+ /**
+ * Событие вызывается перед активацией текущей компоненты
+ *
+ * @returns{Boolean|undefined} если false - активация будет отменена
+ */
+ onActivating: function () {},
+
+ /**
+ * Событие вызывается перед деактивацией текущей компоненты
+ *
+ * @returns {Boolean|undefined} если false - деактивация будет отменена
+ */
+ onDeactivating: function () {},
+
+ /**
+ * Событие вызывается после активации текущей компоненты
+ */
+ onActivated: function () {},
+
+ /**
+ * Событие вызывается после деактивации текущей компоненты
+ */
+ onDeactivated: function () {}
+
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/DataContext.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/DataContext.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,45 @@
+define([ "dojo/_base/declare", "../safe" ], function(declare, safe) {
+ return declare(
+ null,
+ {
+ _params : null,
+
+ _repositories : null,
+
+ constructor : function(opts) {
+ this._params = opts || {};
+ this._repositories = {};
+ },
+
+ getRepository : function(name) {
+ safe.argumentNotEmptyString(name, "name");
+ var repo = this._repositories[name];
+ if (!repo) {
+ repo = this._params[name];
+ if (!repo)
+ throw new Error("The repository '" + name +
+ "' isn't found");
+ if (repo instanceof Function)
+ repo = new repo(); // factory method or constructor
+ if (repo.initialize) {
+ repo.initialize({
+ dataContext : this
+ });
+ } else if (repo.setDataContext) {
+ repo.setDataContext(this);
+ }
+ this._repositories[name] = repo;
+ }
+
+ return repo;
+ },
+
+ dispose : function() {
+ for( var name in this._repositories) {
+ var r = this._repositories[name];
+ if (r.dispose)
+ r.dispose();
+ }
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/MapSchema.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/MapSchema.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,67 @@
+define([ "dojo/_base/declare", "../safe" ], function(declare, safe) {
+ return declare(null, {
+ /**
+ * Отображение одного типа объектов в другой.
+ *
+ * @remarks Отображения являются односторонними, т.е. позволяют
+ * перенести часть содержимого одного объекта в другой. Каждая
+ * схема отображения строится из набора примитивных
+ * отображений, которые будут применены в произвольном порядке.
+ */
+ _schema : null,
+
+ constructor : function(schema) {
+ this._schema = schema;
+ },
+
+ /**
+ * Осуществляет отображение одного объекта в другой
+ *
+ * @src{Object} Исходный объект из которого будут взяты данные
+ * @dst{Object}
+ */
+ map : function(src, dst, ctx) {
+ safe.argumentNotNull(src, "src");
+ safe.argumentNotNull(dst, "dst");
+
+ for ( var p in this._schema) {
+ var mapper = this._schema[p];
+ if (mapper instanceof Function) {
+ dst[p] = mapper(src[p]);
+ } else if (mapper && mapper.map) {
+ mapper.map(src, dst, p, ctx);
+ } else {
+ this._defaultMapper(src, dst, p, mapper, ctx);
+ }
+ }
+ },
+
+ _defaultMapper : function(src, dst, prop, opts) {
+ if (typeof (opts) == "string") {
+ if (opts in src)
+ dst[prop] = src[opts];
+ } else if (opts && opts.type instanceof Function) {
+ if (src[prop] instanceof opts.type)
+ dst[prop] = src[prop];
+ else
+ dst[prop] = this._isPrimitiveType(opts.type) ? opts.type
+ .call(null, src[prop]) : new opts.type(src[prop]);
+
+ } else {
+ if (!(prop in src))
+ if (opts && opts.required)
+ throw new Error("The " + prop + "is missing");
+ else
+ return;
+ dst[prop] = src[prop];
+ }
+ },
+
+ _isPrimitiveType : function(type) {
+ return (type === String || type === Number || type === Boolean
+ || type === Number || type === Date);
+ }
+
+ });
+
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/ObjectStore.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/ObjectStore.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,174 @@
+define([ "dojo/_base/declare", "dojo/_base/lang", "dojo/_base/array",
+ "../safe", "dojo/when", "dojo/Deferred", "dojo/store/util/QueryResults" ], function(declare,
+ lang, array, safe, when, Deferred, QueryResults) {
+ /**
+ * @module implab/data/RestStore
+ *
+ * Реализует шаблон репозитария dojo/store над уже имеющимся хранилищем. При получении и
+ * отправке данных в нижележащие хранилище используется implab/data/MapSchema для преобразования
+ * данных.
+ */
+ return declare(null, {
+
+ model: null,
+
+ mapping: null,
+
+ _dataContext: null,
+
+ _store : null, // backing store
+
+ _cache : null,
+
+ constructor : function(options) {
+ options = options || {};
+
+ if (options.store)
+ this._store = options.store;
+
+ if (options.dataContext) {
+ this._dataContext = options.dataContext;
+ }
+
+ if (options.cache === false) {
+ // no cache at all
+ } else if (options.cache === "string" && options.dataContext) {
+ this._cache = this._dataContext.getCache(options.cache);
+ } else {
+ this._cache = {};
+ }
+ },
+
+ getDataContext : function() {
+ return this._dataContext;
+ },
+
+ // READ
+ get : function(id) {
+ var me = this;
+ var cache = me.getCacheEntry(id);
+ if (cache)
+ return cache;
+ else
+ return when(me._store.get(id), function(data) {
+ return me._mapToObject(id, data);
+ });
+ },
+
+ query : function(query, options) {
+ var me = this;
+ var d = me._store.query(query, options);
+ var result = QueryResults(when(d, function(data) {
+ return array.map(data, function(item) {
+ return me._mapToObject(me._store.getIdentity(item), item);
+ });
+ }));
+ result.total = d.total;
+ return result;
+ },
+
+ getIdentity : function(object) {
+ return object.getId();
+ },
+
+ // UPDATE
+ put : function(object, directives) {
+ return this._store.put(this._mapFromObject(object), directives);
+ },
+
+ // INSERT
+ add : function(object, directives) {
+ var me = this;
+ // добавляем в хранилище данные, сохраняем в кеше объект с
+ // полученным идентификатором
+ return when(
+ me._store.add(this._mapFromObject(object), directives),
+ function(id) {
+ object.attach(id, me);
+ me.storeCacheEntry(id, object);
+ return id;
+ });
+ },
+
+ // DELETE
+ remove : function(id) {
+ var me = this;
+ return when(me._store.remove(id), function() {
+ me.removeCacheEntry(id);
+ });
+ },
+
+ _mapToObject : function(id, data) {
+ var instance = this.createInstance(id);
+ this.populateInstance(instance, data);
+ return instance;
+ },
+
+ _mapFromObject : function(object) {
+ return this.serializeInstance(object);
+ },
+
+ getCacheEntry : function(id) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+
+ return this._cache[id];
+ },
+
+ storeCacheEntry : function(id, object) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+
+ this._cache[id] = object;
+ },
+
+ removeCacheEntry : function(id) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+ delete this._cache[id];
+ },
+
+ /** Создает экземпляр сущности с указанным идентификатором, либо извлекает из кеша, если таковая уже имеется.
+ * @remarks
+ * Технически сюда можно было бы дополнительно передать данные для ининциализации объекта,
+ * но концептуально это не верно, поскольку процесс чтения объекта состоит из двух этапов:
+ * 1. Создание пустого объекта (createInstance)
+ * 2. Заполнение объекта при помощи схемы отображения (populateInstance)
+ * при этом первый этап может быть выполнен за долго до второго, например,
+ * при создании заглушек в процессе установления ссылок между объектами.
+ */
+ createInstance : function(id) {
+ var instance = this.getCacheEntry(id);
+ if (!instance) {
+ instance = this.createInstanceImpl(id);
+ this.storeCacheEntry(id, instance);
+ }
+ return instance;
+ },
+
+ /** Непосредственно создает экземпляр сущнсти, т.е. является фабричным методом.
+ * @param {String} id идентификатор создаваемого экземпляра.
+ */
+ createInstanceImpl : function(id) {
+ var opts = {
+ dataContext : this.getDataContext(),
+ id : id
+ };
+
+ return new this.itemsType(opts);
+ },
+
+ populateInstance : function(instance, data) {
+ this.mapping.readData(instance, data,this.getDataContext());
+ if (instance.onPopulate)
+ instance.onPopulate();
+ },
+
+ serializeInstance : function(instance) {
+ var data = {};
+ this.mapping.writeData(instance, data, this.getDataContext());
+ return data;
+ }
+
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/RestStore.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/RestStore.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,166 @@
+define([ "dojo/_base/declare", "dojo/_base/lang", "dojo/_base/array",
+ "../safe", "dojo/when", "dojo/Deferred", "dojo/store/util/QueryResults" ], function(declare,
+ lang, array, safe, when, Deferred, QueryResults) {
+ /**
+ * @module implab/data/RestStore
+ *
+ * Реализует шаблон репозитария dojo/store над уже имеющимся хранилищем. При получении и
+ * отправке данных в нижележащие хранилище используется implab/data/MapSchema для преобразования
+ * данных.
+ */
+ return declare(null, {
+
+ itemsType : null,
+
+ _dataContext : null,
+
+ _store : null, // backing store
+ _cache : null,
+
+ constructor : function(options) {
+ options = options || {};
+
+ this._cache = {};
+ if (options.store)
+ this._store = options.store;
+ if (options.dataContext)
+ this._dataContext = options.dataContext;
+ },
+
+ setDataContext : function(v) {
+ this._dataContext = v;
+ },
+
+ getDataContext : function() {
+ return this._dataContext;
+ },
+
+ // READ
+ get : function(id) {
+ var me = this;
+ var cache = me.getCacheEntry(id);
+ if (cache)
+ return cache;
+ else
+ return when(me._store.get(id), function(data) {
+ return me._mapToObject(id, data);
+ });
+ },
+
+ query : function(query, options) {
+ var me = this;
+ var d = me._store.query(query, options);
+ var result = QueryResults(when(d, function(data) {
+ return array.map(data, function(item) {
+ return me._mapToObject(me._store.getIdentity(item), item);
+ });
+ }));
+ result.total = d.total;
+ return result;
+ },
+
+ getIdentity : function(object) {
+ return object.getId();
+ },
+
+ // UPDATE
+ put : function(object, directives) {
+ return this._store.put(this._mapFromObject(object), directives);
+ },
+
+ // INSERT
+ add : function(object, directives) {
+ var me = this;
+ // добавляем в хранилище данные, сохраняем в кеше объект с
+ // полученным идентификатором
+ return when(
+ me._store.add(this._mapFromObject(object), directives),
+ function(id) {
+ object.attach(id, me);
+ me.storeCacheEntry(id, object);
+ return id;
+ });
+ },
+
+ // DELETE
+ remove : function(id) {
+ var me = this;
+ return when(me._store.remove(id), function() {
+ me.removeCacheEntry(id);
+ });
+ },
+
+ _mapToObject : function(id, data) {
+ var instance = this.createInstance(id);
+ this.populateInstance(instance, data);
+ return instance;
+ },
+
+ _mapFromObject : function(object) {
+ return this.serializeInstance(object);
+ },
+
+ getCacheEntry : function(id) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+
+ return this._cache[id];
+ },
+
+ storeCacheEntry : function(id, object) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+
+ this._cache[id] = object;
+ },
+
+ removeCacheEntry : function(id) {
+ safe.argumentNotNull(id, "id");
+ id = id.toString();
+ delete this._cache[id];
+ },
+
+ /** Создает экземпляр сущности с указанным идентификатором, либо извлекает из кеша, если таковая уже имеется.
+ * @remarks
+ * Технически сюда можно было бы дополнительно передать данные для ининциализации объекта,
+ * но концептуально это не верно, поскольку процесс чтения объекта состоит из двух этапов:
+ * 1. Создание пустого объекта (createInstance)
+ * 2. Заполнение объекта при помощи схемы отображения (populateInstance)
+ * при этом первый этап может быть выполнен за долго до второго, например,
+ * при создании заглушек в процессе установления ссылок между объектами.
+ */
+ createInstance : function(id) {
+ var instance = this.getCacheEntry(id);
+ if (!instance) {
+ instance = this.createInstanceImpl(id);
+ this.storeCacheEntry(id, instance);
+ }
+ return instance;
+ },
+
+ /** Непосредственно создает экземпляр сущнсти, т.е. является фабричным методом.
+ * @param {String} id идентификатор создаваемого экземпляра.
+ */
+ createInstanceImpl : function(id) {
+ var opts = {
+ dataContext : this.getDataContext(),
+ id : id
+ };
+
+ return new this.itemsType(opts);
+ },
+
+ populateInstance : function(instance, data) {
+ this.itemsType.readData(instance, data,this.getDataContext());
+ if (instance.onPopulate)
+ instance.onPopulate();
+ },
+
+ serializeInstance : function(instance) {
+ var data = {};
+ this.itemsType.writeData(instance, data, this.getDataContext());
+ return data;
+ }
+
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/StatefullStoreAdapter.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/StatefullStoreAdapter.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,19 @@
+define(["dojo/_base/declare", "dojo/_base/array", "../safe", "./StoreAdapter"], function(declare, array, safe ,AdapterStore){
+ return declare([AdapterStore], {
+ _attrs : null,
+
+ constructor : function(opts) {
+ safe.argumentNotEmptyArray(opts.attrs, "opts.attrs");
+ this._attrs = opts.attrs;
+ },
+
+ mapItem : function(item) {
+ var result = {};
+ array.forEach(this._attrs, function(p) {
+ result[p] = item.get(p);
+ });
+ return result;
+ }
+ });
+
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/StoreAdapter.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/StoreAdapter.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,110 @@
+define([
+ "dojo/_base/declare",
+ "../safe",
+ "dojo/when",
+ "dojo/store/util/QueryResults" ],
+
+function(declare, safe, when, QueryResults) {
+
+ "use strict";
+
+ /**
+ * Обертка вокруг произвольного хранилища, только для чтения. Используется
+ * для преобразования данных, например, отображения в списках элементов
+ * пространственных данных.
+ */
+ return declare(null, {
+ /**
+ * @type{String} Свойство, хранящее идентификатор
+ */
+ idProperty : null,
+
+ _store : null,
+
+ /**
+ * @param{String} opts.idProperty Имя свойства, в которое будет записан
+ * идентификатор, если не указан, то идентификатор будет
+ * взят из родительского хранилища или использоваться
+ * строка id
+ * @param{dojo.store} opts.store Родительское хранилище
+ */
+ constructor : function(opts) {
+ safe.argumentNotNull(opts, "opts");
+ safe.argumentNotNull(opts.store, "opts.store");
+
+ this._store = opts.store;
+ delete opts.store;
+ declare.safeMixin(this, opts);
+ this.idProperty = opts.idProperty || this._store.idProperty || "id";
+ },
+
+ getParentStore : function() {
+ return this._store;
+ },
+
+ get : function(id) {
+ var me = this;
+ return when(me._store.get(id), function(x) {
+ var m = me.mapItem(x);
+ if (!(me.idProperty in m))
+ m[me.idProperty] = id;
+ return m;
+ });
+ },
+
+ /**
+ * Выполняет запрос в родительском хранилище, для этого используется
+ * translateQuery для подготовки запроса, затем,
+ * mapItem для преобразования результатов.
+ */
+ query : function(q, options) {
+ var me = this, store = this._store;
+ return when(store.query(me.translateQuery(q), me
+ .translateOptions(options)), function(res) {
+ var total = res.total;
+ var mapped = res.map(function(x) {
+ var m = me.mapItem(x);
+ if (!(me.idProperty in m))
+ m[me.idProperty] = store.getIdentity &&
+ store.getIdentity(x);
+ return m;
+ });
+ mapped.total = total;
+ var results = new QueryResults(mapped);
+ console.log(results);
+ return results;
+ });
+ },
+
+ getIdentity : function(obj) {
+ return obj && obj[this.idProperty];
+ },
+
+ /**
+ * Преобразование запроса в формат родительского хранилища.
+ *
+ * @param{Object} q Запрос в формате текущего хранилища
+ * @returns{Object} Запрос в формате родительского хранилища
+ */
+ translateQuery : function(q) {
+ return q;
+ },
+
+ translateOptions : function(options) {
+ return options;
+ },
+
+ /**
+ * Преобразование объекта из родительского хранилища. При преобразовании
+ * в объекте можно задать идентификатор, иначе идентификатор будет
+ * автоматически получен и присвоен из родительского хранилища
+ *
+ * @param{Object} item Объект из родительского хранилища
+ * @returns{Object} результат преобразования
+ */
+ mapItem : function(item) {
+ return item;
+ }
+ });
+
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/_ModelBase.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/_ModelBase.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,37 @@
+define(["dojo/_base/declare"], function(declare) {
+
+ return declare(null, {
+ dataContext : null,
+ idField : "id",
+ loaded : false,
+
+ constructor : function(opts){
+ if (opts) {
+ if(opts.dataContext)
+ this.dataContext = opts.dataContext;
+ if(opts.id)
+ this[this.idField] = opts.id;
+ }
+ },
+
+ getId : function() {
+ return this[this.idField];
+ },
+
+ attach : function(id, dc) {
+ if (this.dataContext)
+ throw new Error("The object is already attached");
+ this[this.idField] = id;
+ this.dataContext = dc;
+ },
+
+ isAttached : function() {
+ return this.dataContext ? true : false;
+ },
+
+ onPopulate : function() {
+ this.loaded = true;
+ }
+
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/_StatefulModelMixin.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/_StatefulModelMixin.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,5 @@
+define(["dojo/_base/declare", "dojo/Stateful"], function(declare, Stateful) {
+ return declare([Stateful], {
+
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/data/declare-model.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/data/declare-model.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,72 @@
+define([ "dojo/_base/declare", "./_ModelBase", "./MapSchema" ], function(
+ declare, _ModelBase, MapSchema) {
+ /**
+ * Создает новый класс, унаследованный от ./ModelBase, с указанной схемой
+ * отображения данных.
+ *
+ * @details Модель представляет собой объект, живущий в рамках контекста
+ * данных, также имеющий две схемы отображения: из модели хранения
+ * в источнике данных (toObjectMap) и наооборот в модель хранения в
+ * источнике данных (fromObjectMap).
+ *
+ * Описание схемы выглядит следующим образом
+ *
+ * {
+ * name : null, // отображение в обе стороны без преобразования
+ *
+ * age : Number, // при преобразоваении к объекту поле будет преобразовано dst.age = Number(src.age)
+ * // обратное преобразование отсутстсвует
+ *
+ * age : [Number, null] // тоже самое что и age : Number
+ *
+ * date : [Date, function(v) { return v.toString() }] // указывается преобразование в одну и в другую сторону
+ * }
+ *
+ */
+ return function(schema, mixins, opts) {
+ var fromObjectSchema = {}, toObjectSchema = {};
+ if (schema !== null && schema !== undefined) {
+ for ( var p in schema) {
+ var mapper = schema[p];
+
+ if (mapper instanceof Array) {
+ toObjectSchema[p] = mapper[0];
+ fromObjectSchema[p] = mapper[1];
+ } else {
+ toObjectSchema[p] = mapper;
+ fromObjectSchema[p] = null;
+ }
+ }
+ }
+
+ if (arguments.length < 3) {
+ opts = mixins;
+ mixins = undefined;
+ }
+
+ var base = [ _ModelBase ];
+ if (mixins) {
+ if (mixins instanceof Array)
+ base = base.concat(mixins);
+ else
+ base.push(mixins);
+ }
+
+ var model = declare(base, opts);
+
+ model.toObjectMap = new MapSchema(toObjectSchema);
+
+ model.fromObjectMap = new MapSchema(fromObjectSchema);
+
+ model.readData = function(that, data, context) {
+ model.toObjectMap.map(data, that, context);
+ };
+
+ model.writeData = function(that, data, context) {
+ data = data || {};
+ model.fromObjectMap.map(that, data, context);
+ };
+
+ return model;
+ };
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/declare.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/declare.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,6 @@
+define([
+ './declare/_load!'
+], function(declare) {
+ 'use strict';
+ return declare;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/declare/_load.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/declare/_load.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,12 @@
+define([], function () {
+ 'use strict';
+
+ return {
+ load: function (id, require, callback) {
+ require(['dojo/_base/declare'], function (declare) {
+ callback(declare);
+ });
+ }
+ };
+
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/declare/override.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/declare/override.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,73 @@
+"use strict";
+define([], function () {
+ var slice = Array.prototype.slice;
+ var override = function (method) {
+ var proxy;
+
+ /** @this target object */
+ proxy = function () {
+ var me = this;
+ var inherited = (this.getInherited && this.getInherited(proxy.nom, {
+ callee: proxy
+ })) || function () {};
+
+ return method.apply(me, [function () {
+ return inherited.apply(me, arguments);
+ }].concat(slice.apply(arguments)));
+ };
+
+ proxy.method = method;
+ proxy.overrides = true;
+
+ return proxy;
+ };
+
+ override.before = function (method) {
+ var proxy;
+
+ /** @this target object */
+ proxy = function () {
+ var me = this;
+ var inherited = (this.getInherited && this.getInherited(proxy.nom, {
+ callee: proxy
+ })) || function () {};
+
+
+ method.apply(me, arguments);
+ return inherited.apply(me, arguments);
+ };
+
+ proxy.method = method;
+ proxy.overrides = true;
+
+ return proxy;
+ };
+
+ override.after = function (method) {
+ var proxy;
+
+ /** @this target object */
+ proxy = function () {
+ var me = this;
+ var inherited = (this.getInherited && this.getInherited(proxy.nom, {
+ callee: proxy
+ })) || function () {};
+
+ inherited.apply(me, arguments);
+
+ return method.apply(me, arguments);
+ };
+
+ proxy.method = method;
+ proxy.overrides = true;
+
+ return proxy;
+ };
+
+ override.hide = function (method) {
+ method.overrides = false;
+ return method;
+ };
+
+ return override;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/ActivationContext.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/ActivationContext.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,138 @@
+define([
+ "../declare",
+ "../safe",
+ "./Descriptor",
+ "./ValueDescriptor",
+ "../log/trace!"
+], function (declare, safe, Descriptor, Value, trace) {
+ var Context = declare(null, {
+
+ _cache: null,
+
+ _services: null,
+
+ _stack: null,
+
+ _visited: null,
+
+ container: null,
+
+ _trace: true,
+
+ constructor: function (container, services, cache, visited) {
+ safe.argumentNotNull(container, "container");
+ safe.argumentNotNull(services, "services");
+
+ this._visited = visited || {};
+ this._stack = [];
+ this._cache = cache || {};
+ this._services = services;
+ this.container = container;
+ },
+
+ getService: function (name, def) {
+ var d = this._services[name];
+
+ if (!d)
+ if (arguments.length > 1)
+ return def;
+ else
+ throw new Error("Service '" + name + "' not found");
+
+ return d.activate(this, name);
+ },
+
+ /**
+ * registers services local to the the activation context
+ *
+ * @name{string} the name of the service
+ * @service{string} the service descriptor to register
+ */
+ register: function (name, service) {
+ safe.argumentNotEmptyString(name, "name");
+
+ if (!(service instanceof Descriptor))
+ service = new Value(service, true);
+ this._services[name] = service;
+ },
+
+ clone: function () {
+ return new Context(
+ this.container,
+ Object.create(this._services),
+ this._cache,
+ this._visited
+ );
+
+ },
+
+ has: function (id) {
+ return id in this._cache;
+ },
+
+ get: function (id) {
+ return this._cache[id];
+ },
+
+ store: function (id, value) {
+ return (this._cache[id] = value);
+ },
+
+ parse: function (data, name) {
+ var me = this;
+ if (safe.isPrimitive(data))
+ return data;
+
+ if (data instanceof Descriptor) {
+ return data.activate(this, name);
+ } else if (data instanceof Array) {
+ me.enter(name);
+ var v = data.map(function (x, i) {
+ return me.parse(x, "." + i);
+ });
+ me.leave();
+ return v;
+ } else {
+ me.enter(name);
+ var result = {};
+ for (var p in data)
+ result[p] = me.parse(data[p], "." + p);
+ me.leave();
+ return result;
+ }
+ },
+
+ visit: function (id) {
+ var count = this._visited[id] || 0;
+ this._visited[id] = count + 1;
+ return count;
+ },
+
+ getStack: function () {
+ return this._stack.slice().reverse();
+ },
+
+ enter: function (name, d, localize) {
+ if (this._trace)
+ trace.log("enter " + name + " " + (d || "") +
+ (localize ? " localize" : ""));
+ this._stack.push({
+ name: name,
+ service: d,
+ scope: this._services
+ });
+ if (localize)
+ this._services = Object.create(this._services);
+ },
+
+ leave: function () {
+ var ctx = this._stack.pop();
+ this._services = ctx.scope;
+
+ if (this._trace)
+ trace.log("leave " + ctx.name + " " + (ctx.service || ""));
+ }
+ });
+
+ return Context;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/ActivationError.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/ActivationError.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,39 @@
+define([
+ "../declare"
+], function (declare) {
+ return declare(null, {
+ activationStack: null,
+
+ service: null,
+
+ innerException: null,
+
+ message: null,
+
+ constructor: function (service, activationStack, innerException) {
+ this.message = "Failed to activate the service";
+ this.activationStack = activationStack;
+ this.service = service;
+ this.innerException = innerException;
+ },
+
+ toString: function () {
+ var parts = [this.message];
+ if (this.service)
+ parts.push("when activating: " + this.service.toString());
+
+ if (this.innerException)
+ parts.push("caused by: " + this.innerException.toString());
+
+ if (this.activationStack) {
+ parts.push("at");
+ this.activationStack.forEach(function (x) {
+ parts.push(" " + x.name + " " +
+ (x.service ? x.service.toString() : ""));
+ });
+ }
+
+ return parts.join("\n");
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/Container.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/Container.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,299 @@
+define([
+ "../declare",
+ "../safe",
+ "../Uuid",
+ "../Deferred",
+ "./ActivationContext",
+ "./Descriptor",
+ "./ValueDescriptor",
+ "./ReferenceDescriptor",
+ "./ServiceDescriptor",
+ "./ActivationError"
+], function (
+ declare,
+ safe,
+ Uuid,
+ Deferred,
+ ActivationContext,
+ Descriptor,
+ Value,
+ Reference,
+ Service,
+ ActivationError) {
+ var Container = declare(null, {
+ _services: null,
+ _cache: null,
+ _cleanup: null,
+ _root: null,
+ _parent: null,
+
+ constructor: function (parent) {
+ this._parent = parent;
+ this._services = parent ? Object.create(parent._services) : {};
+ this._cache = {};
+ this._cleanup = [];
+ this._root = parent ? parent.getRootContainer() : this;
+ this._services.container = new Value(this, true);
+ },
+
+ getRootContainer: function () {
+ return this._root;
+ },
+
+ getParent: function () {
+ return this._parent;
+ },
+
+ /**
+ *
+ */
+ getService: function (name, def) {
+ var d = this._services[name];
+ if (!d)
+ if (arguments.length > 1)
+ return def;
+ else
+ throw new Error("Service '" + name + "' isn't found");
+ if (d.isInstanceCreated())
+ return d.getInstance();
+
+ var context = new ActivationContext(this, this._services);
+
+ try {
+ return d.activate(context, name);
+ } catch (error) {
+ throw new ActivationError(name, context.getStack(), error);
+ }
+ },
+
+ register: function (name, service) {
+ if (arguments.length == 1) {
+ var data = name;
+ for (name in data)
+ this.register(name, data[name]);
+ } else {
+ if (!(service instanceof Descriptor))
+ service = new Value(service, true);
+ this._services[name] = service;
+ }
+ return this;
+ },
+
+ onDispose: function (callback) {
+ if (!(callback instanceof Function))
+ throw new Error("The callback must be a function");
+ this._cleanup.push(callback);
+ },
+
+ dispose: function () {
+ if (this._cleanup) {
+ for (var i = 0; i < this._cleanup.length; i++)
+ this._cleanup[i].call(null);
+ this._cleanup = null;
+ }
+ },
+
+ /**
+ * @param{String|Object} config
+ * The configuration of the contaier. Can be either a string or an object,
+ * if the configuration is an object it's treated as a collection of
+ * services which will be registed in the contaier.
+ *
+ * @param{Function} opts.contextRequire
+ * The function which will be used to load a configuration or types for services.
+ *
+ */
+ configure: function (config, opts) {
+ var p, me = this,
+ contextRequire = (opts && opts.contextRequire);
+
+ if (typeof (config) === "string") {
+ p = new Deferred();
+ if (!contextRequire) {
+ var shim = [config, new Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
+ define(shim, ["require", config], function (ctx, data) {
+ p.resolve([data, {
+ contextRequire: ctx
+ }]);
+ });
+ require([shim]);
+ } else {
+ // TODO how to get correct contextRequire for the relative config module?
+ contextRequire([config], function (data) {
+ p.resolve([data, {
+ contextRequire: contextRequire
+ }]);
+ });
+ }
+
+ return p.then(function (args) {
+ return me._configure.apply(me, args);
+ });
+ } else {
+ return me._configure(config, opts);
+ }
+ },
+
+ createChildContainer: function () {
+ return new Container(this);
+ },
+
+ has: function (id) {
+ return id in this._cache;
+ },
+
+ get: function (id) {
+ return this._cache[id];
+ },
+
+ store: function (id, value) {
+ return (this._cache[id] = value);
+ },
+
+ _configure: function (data, opts) {
+ var typemap = {},
+ d = new Deferred(),
+ me = this,
+ p,
+ contextRequire = (opts && opts.contextRequire) || require;
+
+ var services = {};
+
+ for (p in data) {
+ var service = me._parse(data[p], typemap);
+ if (!(service instanceof Descriptor))
+ service = new Value(service, false);
+ services[p] = service;
+ }
+
+ me.register(services);
+
+ var names = [];
+
+ for (p in typemap)
+ names.push(p);
+
+ if (names.length) {
+ contextRequire(names, function () {
+ for (var i = 0; i < names.length; i++)
+ typemap[names[i]] = arguments[i];
+ d.resolve(me);
+ });
+ } else {
+ d.resolve(me);
+ }
+ return d.promise;
+ },
+
+ _parse: function (data, typemap) {
+ if (safe.isPrimitive(data) || data instanceof Descriptor)
+ return data;
+ if (data.$dependency)
+ return new Reference(
+ data.$dependency,
+ data.lazy,
+ data.optional,
+ data["default"],
+ data.services && this._parseObject(data.services, typemap));
+ if (data.$value) {
+ var raw = !data.parse;
+ return new Value(raw ? data.$value : this._parse(
+ data.$value,
+ typemap), raw);
+ }
+ if (data.$type || data.$factory)
+ return this._parseService(data, typemap);
+ if (data instanceof Array)
+ return this._parseArray(data, typemap);
+
+ return this._parseObject(data, typemap);
+ },
+
+ _parseService: function (data, typemap) {
+ var me = this,
+ opts = {
+ owner: this
+ };
+ if (data.$type) {
+
+ opts.type = data.$type;
+
+ if (typeof (data.$type) === "string") {
+ typemap[data.$type] = null;
+ opts.typeMap = typemap;
+ }
+ }
+
+ if (data.$factory)
+ opts.factory = data.$factory;
+
+ if (data.services)
+ opts.services = me._parseObject(data.services, typemap);
+ if (data.inject)
+ opts.inject = data.inject instanceof Array ? data.inject.map(function (x) {
+ return me._parseObject(x, typemap);
+ }) : me._parseObject(data.inject, typemap);
+ if (data.params)
+ opts.params = me._parse(data.params, typemap);
+
+ if (data.activation) {
+ if (typeof (data.activation) === "string") {
+ switch (data.activation.toLowerCase()) {
+ case "singleton":
+ opts.activation = Service.SINGLETON;
+ break;
+ case "container":
+ opts.activation = Service.CONTAINER;
+ break;
+ case "hierarchy":
+ opts.activation = Service.HIERARCHY;
+ break;
+ case "context":
+ opts.activation = Service.CONTEXT;
+ break;
+ case "call":
+ opts.activation = Service.CALL;
+ break;
+ default:
+ throw new Error("Unknown activation type: " +
+ data.activation);
+ }
+ } else {
+ opts.activation = Number(data.activation);
+ }
+ }
+
+ if (data.cleanup)
+ opts.cleanup = data.cleanup;
+
+ return new Service(opts);
+ },
+
+ _parseObject: function (data, typemap) {
+ if (data.constructor &&
+ data.constructor.prototype !== Object.prototype)
+ return new Value(data, true);
+
+ var o = {};
+
+ for (var p in data)
+ o[p] = this._parse(data[p], typemap);
+
+ return o;
+ },
+
+ _parseArray: function (data, typemap) {
+ if (data.constructor &&
+ data.constructor.prototype !== Array.prototype)
+ return new Value(data, true);
+
+ var me = this;
+ return data.map(function (x) {
+ return me._parse(x, typemap);
+ });
+ }
+
+ });
+
+ return Container;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/Descriptor.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/Descriptor.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,4 @@
+define([], function() {
+ // abstract base type for descriptros
+ return function() {};
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/ReferenceDescriptor.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/ReferenceDescriptor.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,90 @@
+define([
+ "../declare", "../safe", "./Descriptor", "./ActivationError", "./ValueDescriptor"
+],
+
+function(declare, safe, Descriptor, ActivationError, Value) {
+ return declare(Descriptor, {
+ _name : null,
+ _lazy : false,
+ _optional : false,
+ _default : undefined,
+
+ constructor : function(name, lazy, optional, def, services) {
+ safe.argumentNotEmptyString(name, "name");
+ this._name = name;
+ this._lazy = Boolean(lazy);
+ this._optional = Boolean(optional);
+ this._default = def;
+ this._services = services;
+ },
+
+ activate : function(context, name) {
+ var me = this;
+
+ context.enter(name, this, true);
+
+ // добавляем сервисы
+ if (me._services) {
+ for ( var p in me._services) {
+ var sv = me._services[p];
+ context.register(p, sv instanceof Descriptor ? sv : new Value(sv, false));
+ }
+ }
+
+ if (me._lazy) {
+ // сохраняем контекст активации
+ context = context.clone();
+ return function(cfg) {
+ // защищаем контекст на случай исключения в процессе
+ // активации
+ var ct = context.clone();
+ try {
+ if (cfg)
+ safe.each(cfg, function(v, k) {
+ ct.register(k, v instanceof Descriptor ? v : new Value(v, false));
+ });
+ return me._optional ? ct.getService(me._name, me._default) : ct
+ .getService(me._name);
+ } catch (error) {
+ throw new ActivationError(me._name, ct.getStack(), error);
+ }
+ };
+ }
+
+ var v = me._optional ? context.getService(me._name, me._default) : context
+ .getService(me._name);
+ context.leave(me);
+ return v;
+ },
+
+ isInstanceCreated : function() {
+ return false;
+ },
+
+ toString : function() {
+ var opts = [];
+ if (this._optional)
+ opts.push("optional");
+ if (this._lazy)
+ opts.push("lazy");
+
+ var parts = [
+ "@ref "
+ ];
+ if (opts.length) {
+ parts.push("{");
+ parts.push(opts.join());
+ parts.push("} ");
+ }
+
+ parts.push(this._name);
+
+ if (!safe.isNull(this._default)) {
+ parts.push(" = ");
+ parts.push(this._default);
+ }
+
+ return parts.join("");
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/ServiceDescriptor.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/ServiceDescriptor.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,289 @@
+define(
+ [
+ "../declare",
+ "../safe",
+ "./Descriptor",
+ "./ValueDescriptor"
+ ],
+
+ function (declare, safe, Descriptor, Value) {
+ var SINGLETON_ACTIVATION = 1,
+ CONTAINER_ACTIVATION = 2,
+ CONTEXT_ACTIVATION = 3,
+ CALL_ACTIVATION = 4,
+ HIERARCHY_ACTIVATION = 5;
+
+ var injectMethod = function (target, method, context, args) {
+ var m = target[method];
+ if (!m)
+ throw new Error("Method '" + method + "' not found");
+
+ if (args instanceof Array)
+ m.apply(target, context.parse(args, "." + method));
+ else
+ m.call(target, context.parse(args, "." + method));
+ };
+
+ var makeClenupCallback = function (target, method) {
+ if (typeof (method) === "string") {
+ return function () {
+ target[method]();
+ };
+ } else {
+ return function () {
+ method(target);
+ };
+ }
+ };
+
+ var cacheId = 0;
+
+ var cls = declare(
+ Descriptor, {
+ _instance: null,
+ _hasInstance: false,
+ _activationType: CALL_ACTIVATION,
+ _services: null,
+ _type: null,
+ _typeMap: null,
+ _factory: null,
+ _params: undefined,
+ _inject: null,
+ _cleanup: null,
+ _cacheId: null,
+ _owner: null,
+
+ constructor: function (opts) {
+ safe.argumentNotNull(opts, "opts");
+ safe.argumentNotNull(opts.owner, "opts.owner");
+
+ this._owner = opts.owner;
+
+ if (!(opts.type || opts.factory))
+ throw new Error(
+ "Either a type or a factory must be specified");
+
+ if (typeof (opts.type) === "string" && !opts.typeMap)
+ throw new Error(
+ "The typeMap is required when the type is specified by its name");
+
+ if (opts.activation)
+ this._activationType = opts.activation;
+ if (opts.type)
+ this._type = opts.type;
+ if (opts.params)
+ this._params = opts.params;
+ if (opts.inject)
+ this._inject = opts.inject instanceof Array ? opts.inject : [opts.inject];
+ if (opts.services)
+ this._services = opts.services;
+ if (opts.factory)
+ this._factory = opts.factory;
+ if (opts.typeMap)
+ this._typeMap = opts.typeMap;
+ if (opts.cleanup) {
+ if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
+ throw new Error(
+ "The cleanup parameter must be either a function or a function name");
+
+ this._cleanup = opts.cleanup;
+ }
+
+ this._cacheId = ++cacheId;
+ },
+
+ activate: function (context, name) {
+
+ // if we have a local service records, register them first
+
+ var instance;
+
+ switch (this._activationType) {
+ case 1: // SINGLETON
+ // if the value is cached return it
+ if (this._hasInstance)
+ return this._instance;
+
+ var tof = this._type || this._factory;
+
+ // create the persistent cache identifier for the type
+ if (safe.isPrimitive(tof))
+ this._cacheId = this._type;
+ else
+ this._cacheId = safe.oid(tof);
+
+ // singletons are bound to the root container
+ var container = context.container.getRootContainer();
+
+ if (container.has(this._cacheId)) {
+ instance = container.get(this._cacheId);
+ } else {
+ instance = this._create(context, name);
+ container.store(this._cacheId, instance);
+ if (this._cleanup)
+ container.onDispose(
+ makeClenupCallback(instance, this._cleanup));
+ }
+
+ this._hasInstance = true;
+ return (this._instance = instance);
+
+ case 2: // CONTAINER
+ //return a cached value
+ if (this._hasInstance)
+ return this._instance;
+
+ // create an instance
+ instance = this._create(context, name);
+
+ // the instance is bound to the container
+ if (this._cleanup)
+ this._owner.onDispose(
+ makeClenupCallback(instance, this._cleanup));
+
+ // cache and return the instance
+ this._hasInstance = true;
+ return (this._instance = instance);
+ case 3: // CONTEXT
+ //return a cached value if one exists
+ if (context.has(this._cacheId))
+ return context.get(this._cacheId);
+ // context context activated instances are controlled by callers
+ return context.store(this._cacheId, this._create(
+ context,
+ name));
+ case 4: // CALL
+ // per-call created instances are controlled by callers
+ return this._create(context, name);
+ case 5: // HIERARCHY
+ // hierarchy activated instances are behave much like container activated
+ // except they are created and bound to the child container
+
+ // return a cached value
+ if (context.container.has(this._cacheId))
+ return context.container.get(this._cacheId);
+
+ instance = this._create(context, name);
+
+ if (this._cleanup)
+ context.container.onDispose(makeClenupCallback(
+ instance,
+ this._cleanup));
+
+ return context.container.store(this._cacheId, instance);
+ default:
+ throw "Invalid activation type: " + this._activationType;
+ }
+ },
+
+ isInstanceCreated: function () {
+ return this._hasInstance;
+ },
+
+ getInstance: function () {
+ return this._instance;
+ },
+
+ _create: function (context, name) {
+ context.enter(name, this, Boolean(this._services));
+
+ if (this._activationType != CALL_ACTIVATION &&
+ context.visit(this._cacheId) > 0)
+ throw new Error("Recursion detected");
+
+ if (this._services) {
+ for (var p in this._services) {
+ var sv = this._services[p];
+ context.register(p, sv instanceof Descriptor ? sv : new Value(sv, false));
+ }
+ }
+
+ var instance;
+
+ if (!this._factory) {
+ var ctor, type = this._type;
+
+ if (typeof (type) === "string") {
+ ctor = this._typeMap[type];
+ if (!ctor)
+ throw new Error("Failed to resolve the type '" +
+ type + "'");
+ } else {
+ ctor = type;
+ }
+
+ if (this._params === undefined) {
+ this._factory = function () {
+ return new ctor();
+ };
+ } else if (this._params instanceof Array) {
+ this._factory = function () {
+ var inst = Object.create(ctor.prototype);
+ var ret = ctor.apply(inst, arguments);
+ return typeof (ret) === "object" ? ret : inst;
+ };
+ } else {
+ this._factory = function (param) {
+ return new ctor(param);
+ };
+ }
+ }
+
+ if (this._params === undefined) {
+ instance = this._factory();
+ } else if (this._params instanceof Array) {
+ instance = this._factory.apply(this, context.parse(
+ this._params,
+ ".params"));
+ } else {
+ instance = this._factory(context.parse(
+ this._params,
+ ".params"));
+ }
+
+ if (this._inject) {
+ this._inject.forEach(function (spec) {
+ for (var m in spec)
+ injectMethod(instance, m, context, spec[m]);
+ });
+ }
+
+ context.leave();
+
+ return instance;
+ },
+
+ // @constructor {singleton} foo/bar/Baz
+ // @factory {singleton}
+ toString: function () {
+ var parts = [];
+
+ parts.push(this._type ? "@constructor" : "@factory");
+
+ parts.push(activationNames[this._activationType]);
+
+ if (typeof (this._type) === "string")
+ parts.push(this._type);
+
+ return parts.join(" ");
+ }
+
+ });
+
+ cls.SINGLETON = SINGLETON_ACTIVATION;
+ cls.CONTAINER = CONTAINER_ACTIVATION;
+ cls.CONTEXT = CONTEXT_ACTIVATION;
+ cls.CALL = CALL_ACTIVATION;
+ cls.HIERARCHY = HIERARCHY_ACTIVATION;
+
+ var activationNames = [
+ "",
+ "{singleton}",
+ "{container}",
+ "{context}",
+ "{call}",
+ "{hierarchy}"
+ ];
+
+ return cls;
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/di/ValueDescriptor.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/di/ValueDescriptor.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,38 @@
+define([ "../declare", "./Descriptor", "../safe" ],
+
+function(declare, Descriptor, safe) {
+ return declare(Descriptor, {
+ _value : undefined,
+ _raw : false,
+ constructor : function(value, raw) {
+ this._value = value;
+ this._raw = Boolean(raw);
+ },
+
+ activate : function(context, name) {
+ context.enter(name, this);
+ var v = this._raw ? this._value : context.parse(
+ this._value,
+ ".params");
+ context.leave(this);
+ return v;
+ },
+
+ isInstanceCreated : function() {
+ return this._raw;
+ },
+
+ getInstance : function() {
+ if (!this._raw)
+ throw new Error("The instance isn't constructed");
+ return this._value;
+ },
+
+ toString : function() {
+ if (this._raw)
+ return "@value {raw}";
+ else
+ return safe.isNull(this._value) ? "@value " : "@value";
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/log/ConsoleLogChannel.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/log/ConsoleLogChannel.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,30 @@
+define(
+ [ "dojo/_base/declare", "../text/format" ],
+ function(declare, format) {
+ return declare(
+ null,
+ {
+ name : null,
+
+ constructor : function(name) {
+ this.name = name;
+ },
+
+ log : function() {
+ console.log(this._makeMsg(arguments));
+ },
+
+ warn : function() {
+ console.warn(this._makeMsg(arguments));
+ },
+
+ error : function() {
+ console.error(this._makeMsg(arguments));
+ },
+
+ _makeMsg : function(args) {
+ return this.name ? this.name + " " +
+ format.apply(null, args) : format.apply(null, args);
+ }
+ });
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/log/_LogMixin.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/log/_LogMixin.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,67 @@
+define([ "dojo/_base/declare" ],
+
+function(declare) {
+ var cls = declare(null, {
+ _logChannel : null,
+
+ _logLevel : 1,
+
+ constructor : function(opts) {
+ if (typeof opts == "object") {
+ if ("logChannel" in opts)
+ this._logChannel = opts.logChannel;
+ if ("logLevel" in opts)
+ this._logLevel = opts.logLevel;
+ }
+ },
+
+ getLogChannel : function() {
+ return this._logChannel;
+ },
+
+ setLogChannel : function(v) {
+ this._logChannel = v;
+ },
+
+ getLogLevel : function() {
+ return this._logLevel;
+ },
+
+ setLogLevel : function(v) {
+ this._logLevel = v;
+ },
+
+ log : function(format) {
+ if (this._logChannel && this._logLevel > 2)
+ this._logChannel.log.apply(this._logChannel, arguments);
+ },
+ warn : function(format) {
+ if (this._logChannel && this._logLevel > 1)
+ this._logChannel.warn.apply(this._logChannel, arguments);
+ },
+ error : function(format) {
+ if (this._logChannel && this._logLevel > 0)
+ this._logChannel.error.apply(this._logChannel, arguments);
+ },
+
+ /**
+ * Used to by widgets
+ */
+ startup : function() {
+ var me = this, parent;
+ if (!me.getLogChannel()) {
+ parent = me;
+ while (parent = parent.getParent()) {
+ if (parent.getLogChannel) {
+ me.setLogChannel(parent.getLogChannel());
+ if(parent.getLogLevel)
+ me.setLogLevel(parent.getLogLevel());
+ break;
+ }
+ }
+ }
+ this.inherited(arguments);
+ }
+ });
+ return cls;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/log/listeners/console.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/log/listeners/console.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,25 @@
+define([], function () {
+ if (console && console.log)
+ return function (ch, name, msg) {
+
+ var args = [ch + ":"];
+
+ switch (name) {
+ case "warn":
+ case "error":
+ case "log":
+ break;
+ default:
+ args.push(name + ":");
+ name = "log";
+ }
+
+
+ if (msg instanceof Array)
+ args.push.apply(args, msg);
+ else
+ args.push(msg);
+
+ console[name].apply(console, args);
+ };
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/log/trace.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/log/trace.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,116 @@
+define(["../text/format"], function (format) {
+ 'use strict';
+
+ var listeners = [];
+ var channels = {};
+
+ var Trace = function (name) {
+ this.name = name;
+ this._subscribers = [];
+ };
+
+ Trace.prototype.debug = function () {
+ if (Trace.level >= 4)
+ this.notify("debug", format.apply(null, arguments));
+ };
+
+ Trace.prototype.log = function () {
+ if (Trace.level >= 3)
+ this.notify("log", format.apply(null, arguments));
+ };
+
+ Trace.prototype.warn = function () {
+ if (Trace.level >= 2)
+ this.notify("warn", format.apply(null, arguments));
+
+ };
+
+ Trace.prototype.error = function () {
+ if (Trace.level >= 1)
+ this.notify("error", format.apply(null, arguments));
+ };
+
+ Trace.prototype.notify = function (name, msg) {
+ var me = this;
+ me._subscribers.forEach(function (cb) {
+ cb(me, name, msg);
+ });
+ };
+
+ Trace.prototype.subscribe = function (cb) {
+ this._subscribers.push(cb);
+ };
+
+ Trace.prototype.toString = function () {
+ return this.name;
+ };
+
+ Trace.createChannel = function (type, name, cb) {
+ var chId = name;
+ if (channels[chId])
+ return channels[chId];
+
+ var channel = new type(chId);
+ channels[chId] = channel;
+
+ Trace._onNewChannel(chId, channel);
+ cb(channel);
+ };
+
+ Trace._onNewChannel = function (chId, ch) {
+ listeners.forEach(function (listener) {
+ listener(chId, ch);
+ });
+ };
+
+ Trace.on = function (filter, cb) {
+ if (arguments.length == 1) {
+ cb = filter;
+ filter = undefined;
+ }
+ var d, test;
+ if (filter instanceof RegExp) {
+ test = function (chId) {
+ return filter.test(chId);
+ };
+ } else if (filter instanceof Function) {
+ test = filter;
+ } else if (filter) {
+ test = function (chId) {
+ return chId == filter;
+ };
+ }
+
+ if (test) {
+ d = function(chId, ch) {
+ if(test(chId))
+ ch.subscribe(cb);
+ };
+ } else {
+ d = function(chId, ch) {
+ ch.subscribe(cb);
+ };
+ }
+ listeners.push(d);
+
+ for(var chId in channels)
+ d(chId,channels[chId]);
+ };
+
+ Trace.load = function (id, require, cb) {
+ if (id)
+ Trace.createChannel(Trace, id, cb);
+ else if (require.module && require.module.mid)
+ Trace.createChannel(Trace, require.module.mid, cb);
+ else
+ require(['module'], function (module) {
+ Trace.createChannel(Trace, module && module.id, cb);
+ });
+ };
+
+ Trace.dynamic = true;
+
+ Trace.level = 4;
+
+ return Trace;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/main.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/main.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,3 @@
+declare([], function(){
+ // does nothing yet...
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/messaging/Client.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/messaging/Client.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,61 @@
+define(
+ [ "dojo/_base/declare", "dojo/_base/lang", "dojo/Evented", "../log/_LogMixin" ],
+
+ function(declare, lang, Evented, _LogMixin) {
+ return declare([ Evented, _LogMixin ], {
+ _session : null,
+ _destination : null,
+ _id : null,
+
+ constructor : function(session, destination, options) {
+ this._destination = destination;
+ this._session = session;
+ },
+
+ getDestination : function() {
+ return this._destination;
+ },
+
+ start : function() {
+ var me = this;
+ return me._session.createClient(me.prepareOptions({})).then(
+ function(id) {
+ me._id = id;
+ return me;
+ });
+ },
+
+ prepareOptions : function(options) {
+ var me = this;
+ options.mode = me.getMode();
+ options.destination = me.getDestination();
+ options.client = function(msg) {
+ me.process(msg);
+ };
+ return options;
+ },
+
+ process : function(msg) {
+ this.warn("Messages are not acceped by this client");
+ },
+
+ stop : function() {
+ var me = this;
+ if (me._id) {
+ me.log("stop");
+ return me._session.deleteClient({'clientId': me._id}).then(function() {
+ me._id = null;
+ return me;
+ });
+ }
+ },
+
+ toString : function() {
+ return "["
+ + [
+ this.getMode().toUpperCase(),
+ this.getDestination(),
+ this._id ].join(',') + "]";
+ }
+ });
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/messaging/Destination.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/messaging/Destination.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,34 @@
+define([ "dojo/_base/declare", "./Listener" ],
+
+function(declare, Listener) {
+ return declare(null, {
+ _session : null,
+ _destination : null,
+ _listenerClass : null,
+
+ constructor : function(session, destination, options) {
+ if (!session)
+ throw new Error("A session is required");
+ if (!destination)
+ throw new Error("A destination is required");
+
+ this._session = session;
+ this._destination = destination;
+ if (options) {
+ if (options.listenerClass)
+ this._listenerClass = options.listenerClass;
+ }
+ },
+
+ listen : function(callback) {
+ var factory = this._listenerClass || Listener;
+ var listener = new factory(this._session, this._destination, {
+ listener : callback
+ });
+ listener.start();
+
+ return listener;
+ }
+
+ });
+});
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/messaging/Listener.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/messaging/Listener.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,64 @@
+define([ "dojo/_base/declare", "dojo/_base/lang", "./Client" ],
+
+function(declare, lang, Client) {
+ return declare([ Client ], {
+ _listener : null,
+
+ constructor : function(session, destination, options) {
+ if (!options || !options.listener)
+ throw new Error("A listener is required");
+ this._listener = options.listener;
+ if (options.transform)
+ this._transform = options.transform;
+ },
+
+ getMode : function() {
+ return "listener";
+ },
+
+ process : function(result) {
+ switch (result.type) {
+ case "message":
+ try {
+ this._handleMessage(result.message);
+ } catch (ex) {
+ var err = new Error("Failed to handle message");
+ err.envelope = result.message;
+ err.innerException = ex;
+ this._handleError(err);
+ }
+ break;
+ case "error":
+ this._handleError(result.error);
+ break;
+ }
+
+ },
+
+ _transform : function(envelope) {
+ return envelope;
+ },
+
+ _handleMessage : function(envelope) {
+ this.log(
+ "MESSAGE type = ${0}, headers = ${2}: ${1}",
+ envelope.bodyType,
+ envelope.body,
+ JSON.stringify(envelope.headers));
+ var data = this._transform(envelope);
+ this._listener(data);
+ this.emit("message", data);
+ },
+
+ _handleError : function(ex) {
+ if (ex.innerException)
+ this.error(
+ "ERROR: ${0} -> ${1}",
+ ex.message,
+ ex.innerException.message);
+ else
+ this.error("ERROR: ${0}", ex.message);
+ this.emit("error", ex);
+ }
+ });
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/messaging/Session.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/messaging/Session.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,217 @@
+define(
+ [
+ "dojo/_base/declare",
+ "dojo/_base/lang",
+ "dojo/request",
+ "./Destination",
+ "dojo/Evented",
+ "dojo/Deferred",
+ "../log/_LogMixin" ],
+
+ function(declare, lang, request, Destination, Evented, Deferred, _LogMixin) {
+
+ var cls = declare(
+ [ Evented, _LogMixin ],
+ {
+ _id : null,
+ _baseUrl : null,
+ _destinations : null,
+ _timeout : 100000,
+ _clients : null,
+ _started : null,
+ _starting : false,
+
+ constructor : function(baseUrl, options) {
+ if (!baseUrl)
+ throw new Error("baseUrl is required");
+ options = options || {};
+
+ this._baseUrl = baseUrl.replace(/\/*$/, "");
+ this._destinations = {};
+ this._pending = [];
+ this._clients = {};
+ if (options.timeout)
+ this._timeout = options.timeout;
+
+ this._started = new Deferred();
+ },
+
+ start : function() {
+ if (this._starting)
+ return this._started;
+ this._starting = true;
+
+ var me = this;
+ me.log("START");
+ request(this._baseUrl, {
+ method : "POST",
+ handleAs : "json"
+ }).then(function(result) {
+ me._id = result;
+ me._emitConnected();
+ me._poll();
+ me._started.resolve(me);
+ }, function(error) {
+ me._emitError(error);
+ me._started.reject(me);
+ });
+ return me._started.promise;
+ },
+
+ createClient : function(options) {
+ if (!options || !options.destination || !options.mode)
+ throw new Error("Invalid argument");
+
+ var me = this;
+
+ return me._started
+ .then(function() {
+ var url = me._makeUrl(me._id);
+ me.log(
+ "CREATE mode=${0}, destination=${1}",
+ options.mode,
+ options.destination);
+
+ return request(url, {
+ method : "POST",
+ data : {
+ mode : options.mode,
+ destination : options.destination
+ },
+ handleAs : 'json'
+ })
+ .then(
+ function(id) {
+ me
+ .log(
+ "CLIENT id=${0}, mode=${1}, destination=${2}",
+ id,
+ options.mode,
+ options.destination);
+ me._clients[id] = options.client
+ ? options.client
+ : function(msg) {
+ me
+ .warn(
+ "The client id=${0}, mode=${1}, destination=${2} isn't accepting mesages",
+ id,
+ options.mode,
+ options.destination);
+ };
+ return id;
+ });
+ });
+
+ },
+
+ deleteClient : function(options) {
+ if (!options || !options.clientId)
+ throw new Error("Invalid argument");
+
+ var me = this, id = options.clientId;
+
+ return me._started.then(function() {
+ var url = me._makeUrl(me._id, options.clientId);
+
+ me.log("DELETE CLIENT ${0}", options.clientId);
+
+ return request(url, {
+ method : "DELETE",
+ handleAs : 'json'
+ }).then(function() {
+ me.log("CLIENT DELETED ${0}", options.clientId);
+ me._clients[id] = undefined;
+ });
+ });
+ },
+
+ _poll : function() {
+ var me = this, url = this._makeUrl(this._id);
+ me.log("POLL timeout=${0}", me._timeout);
+ request(url, {
+ method : "GET",
+ handleAs : "json",
+ query : {
+ timeout : me._timeout
+ }
+ }).then(function(response) {
+ me._handlePoll(response);
+ me._poll();
+ }, function(err) {
+ me.error("POLL faield with ${0}", err);
+ me._emitError(err);
+ });
+ },
+
+ _handlePoll : function(response) {
+ if (!response) {
+ this.log("POLL response undefined, looks like a bug");
+ return;
+ }
+ if (!response.results || !response.results.length) {
+ this.log("POLL response is empty");
+ return;
+ }
+
+ var results = response.results;
+ this.log("POLL got ${0} results", results.length);
+
+ for (var i = 0; i < results.length; i++) {
+ var result = results[i];
+ var client = this._clients[result.clientId];
+ if (!client) {
+ // TODO this could happen due to client isn't
+ // registered yet
+ this.error("Unknown client ${0}", result.clientId);
+ continue;
+ }
+ client.call(this, result);
+ }
+ },
+
+ _emitError : function(err) {
+ this.emit("error", err);
+ },
+
+ _emitConnected : function() {
+ var me = this;
+ me.log("CONNECTED");
+ me.emit("connected");
+ },
+
+ _makeUrl : function() {
+ var parts = [ this._baseUrl ];
+ for (var i = 0; i < arguments.length; i++)
+ parts.push(arguments[i].replace(/\/*$/, ""));
+ return parts.join('/');
+ },
+
+ queue : function(name) {
+ return this._getDestination("queue://" + name);
+ },
+
+ topic : function(name) {
+ return this._getDestination("topic://" + name);
+ },
+
+ _getDestination : function(uri) {
+ if (uri in this._destinations)
+ return this._destinations[uri];
+
+ var dest = new Destination(this, uri);
+ this._destinations[uri] = dest;
+ return dest;
+ },
+
+ toString : function() {
+ return [ "[", "SESSION ", this._id, "]" ].join(" ");
+ }
+ });
+
+ cls.connect = function(url, options) {
+ var session = new cls(url, options);
+ return session.start();
+ };
+
+ return cls;
+ });
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/safe.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/safe.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,323 @@
+define([],
+
+ function () {
+ var _create = Object.create,
+ _keys = Object.keys;
+
+ var safe = null;
+ safe = {
+ argumentNotNull: function (arg, name) {
+ if (arg === null || arg === undefined)
+ throw new Error("The argument " + name + " can't be null or undefined");
+ },
+
+ argumentNotEmptyString: function (arg, name) {
+ if (typeof (arg) !== "string" || !arg.length)
+ throw new Error("The argument '" + name + "' must be a not empty string");
+ },
+
+ argumentNotEmptyArray: function (arg, name) {
+ if (!(arg instanceof Array) || !arg.length)
+ throw new Error("The argument '" + name + "' must be a not empty array");
+ },
+
+ argumentOfType: function (arg, type, name) {
+ if (!(arg instanceof type))
+ throw new Error("The argument '" + name + "' type doesn't match");
+ },
+
+ isNull: function (arg) {
+ return (arg === null || arg === undefined);
+ },
+
+ isPrimitive: function (arg) {
+ return (arg === null || arg === undefined || typeof (arg) === "string" ||
+ typeof (arg) === "number" || typeof (arg) === "boolean");
+ },
+
+ isInteger: function (arg) {
+ return parseInt(arg) == arg;
+ },
+
+ isNumber: function (arg) {
+ return parseFloat(arg) == arg;
+ },
+
+ isString: function (val) {
+ return typeof (val) == "string" || val instanceof String;
+ },
+
+ isNullOrEmptyString: function (str) {
+ if (str === null || str === undefined ||
+ ((typeof (str) == "string" || str instanceof String) && str.length === 0))
+ return true;
+ },
+
+ isNotEmptyArray: function (arg) {
+ return (arg instanceof Array && arg.length > 0);
+ },
+
+ /**
+ * Выполняет метод для каждого элемента массива, останавливается, когда
+ * либо достигнут конец массива, либо функция cb вернула
+ * значение.
+ *
+ * @param{Array | Object} obj массив элементов для просмотра
+ * @param{Function} cb функция, вызываемая для каждого элемента
+ * @param{Object} thisArg значение, которое будет передано в качестве
+ * this в cb.
+ * @returns Результат вызова функции cb, либо undefined
+ * если достигнут конец массива.
+ */
+ each: function (obj, cb, thisArg) {
+ safe.argumentNotNull(cb, "cb");
+ var i, x;
+ if (obj instanceof Array) {
+ for (i = 0; i < obj.length; i++) {
+ x = cb.call(thisArg, obj[i], i);
+ if (x !== undefined)
+ return x;
+ }
+ } else {
+ var keys = _keys(obj);
+ for (i = 0; i < keys.length; i++) {
+ var k = keys[i];
+ x = cb.call(thisArg, obj[k], k);
+ if (x !== undefined)
+ return x;
+ }
+ }
+ },
+
+ /**
+ * Копирует свойства одного объекта в другой.
+ *
+ * @param{Any} dest объект в который нужно скопировать значения
+ * @param{Any} src источник из которого будут копироваться значения
+ * @tmpl{Object|Array} tmpl шаблон по которому будет происходить
+ * копирование. Если шаблон является массивом
+ * (список свойств), тогда значения этого массива
+ * являются именами свойсвт которые будут
+ * скопированы. Если шаблон является объектом (карта
+ * преобразования имен свойств src->dst), тогда
+ * копирование будет осуществляться только
+ * собственных свойств источника, присутсвующих в
+ * шаблоне, при этом значение свойства шаблона
+ * является именем свойства в которое будет
+ * произведено коприрование
+ */
+ mixin: function (dest, src, tmpl) {
+ safe.argumentNotNull(dest, "dest");
+ if (!src)
+ return dest;
+
+ var keys, i, p;
+ if (arguments.length < 3) {
+ keys = _keys(src);
+ for (i = 0; i < keys.length; i++) {
+ p = keys[i];
+ dest[p] = src[p];
+ }
+ } else {
+ if (tmpl instanceof Array) {
+ for (i = 0; i < tmpl.length; i++) {
+ p = tmpl[i];
+ if (p in src)
+ dest[p] = src[p];
+ }
+
+ } else {
+ keys = _keys(src);
+ for (i = 0; i < keys.length; i++) {
+ p = keys[i];
+ if (p in tmpl)
+ dest[tmpl[p]] = src[p];
+ }
+ }
+ }
+ return dest;
+ },
+
+ /** Wraps the specified function to emulate an asynchronous execution.
+ * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
+ * @param{Function|String} fn [Required] Function wich will be wrapped.
+ */
+ async: function (fn, thisArg) {
+ if (arguments.length == 2 && !(fn instanceof Function))
+ fn = thisArg[fn];
+
+ if (fn == null)
+ throw new Error("The function must be specified");
+
+ function wrapresult(x, e) {
+ if (e) {
+ return {
+ then: function (cb, eb) {
+ try {
+ return eb ? wrapresult(eb(e)) : this;
+ } catch (e2) {
+ return wrapresult(null, e2);
+ }
+ }
+ };
+ } else {
+ if (x && x.then)
+ return x;
+ return {
+ then : function(cb) {
+ try {
+ return cb ? wrapresult(cb(x)) : this;
+ } catch(e2) {
+ return wrapresult(e2);
+ }
+ }
+ };
+ }
+ }
+
+ try {
+ return wrapresult(fn.apply(thisArg, arguments));
+ } catch (e) {
+ return wrapresult(null, e);
+ };
+ },
+
+ create: function () {
+ if (console && console.warn)
+ console.warn("implab/safe::create is deprecated use Object.create instead");
+ _create.apply(this, arguments);
+ },
+
+ delegate: function (target, method) {
+ if (!(method instanceof Function)) {
+ this.argumentNotNull(target, "target");
+ method = target[method];
+ }
+
+ if (!(method instanceof Function))
+ throw new Error("'method' argument must be a Function or a method name");
+
+ return function () {
+ return method.apply(target, arguments);
+ };
+ },
+
+ /**
+ * Для каждого элемента массива вызывает указанную функцию и сохраняет
+ * возвращенное значение в массиве результатов.
+ *
+ * @remarks cb может выполняться асинхронно, при этом одновременно будет
+ * только одна операция.
+ *
+ * @async
+ */
+ pmap: function (items, cb) {
+ safe.argumentNotNull(cb, "cb");
+
+ if (items && items.then instanceof Function)
+ return items.then(function (data) {
+ return safe.pmap(data, cb);
+ });
+
+ if (safe.isNull(items) || !items.length)
+ return items;
+
+ var i = 0,
+ result = [];
+
+ function next() {
+ var r, ri;
+
+ function chain(x) {
+ result[ri] = x;
+ return next();
+ }
+
+ while (i < items.length) {
+ r = cb(items[i], i);
+ ri = i;
+ i++;
+ if (r && r.then) {
+ return r.then(chain);
+ } else {
+ result[ri] = r;
+ }
+ }
+ return result;
+ }
+
+ return next();
+ },
+
+ /**
+ * Для каждого элемента массива вызывает указанную функцию, результаты
+ * не сохраняются
+ *
+ * @remarks cb может выполняться асинхронно, при этом одновременно будет
+ * только одна операция.
+ * @async
+ */
+ pfor: function (items, cb) {
+ safe.argumentNotNull(cb, "cb");
+
+ if (items && items.then instanceof Function)
+ return items.then(function (data) {
+ return safe.pmap(data, cb);
+ });
+
+ if (safe.isNull(items) || !items.length)
+ return items;
+
+ var i = 0;
+
+ function next() {
+ while (i < items.length) {
+ var r = cb(items[i], i);
+ i++;
+ if (r && r.then)
+ return r.then(next);
+ }
+ }
+
+ return next();
+ },
+
+ /**
+ * Выбирает первый элемент из последовательности, или обещания, если в
+ * качестве параметра используется обещание, оно должно вернуть массив.
+ *
+ * @param{Function} cb обработчик результата, ему будет передан первый
+ * элемент последовательности в случае успеха
+ * @param{Fucntion} err обработчик исключения, если массив пустой, либо
+ * не массив
+ *
+ * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
+ * обещание, либо первый элемент.
+ * @async
+ */
+ first: function (sequence, cb, err) {
+ if (sequence) {
+ if (sequence.then instanceof Function) {
+ return sequence.then(function (res) {
+ return safe.first(res, cb, err);
+ }, err);
+ } else if (sequence && "length" in sequence) {
+ if (sequence.length === 0) {
+ if (err)
+ return err(new Error("The sequence is empty"));
+ else
+ throw new Error("The sequence is empty");
+ }
+ return cb ? cb(sequence[0]) : sequence[0];
+ }
+ }
+
+ if (err)
+ return err(new Error("The sequence is required"));
+ else
+ throw new Error("The sequence is required");
+ }
+ };
+
+ return safe;
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/text/format-compile.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/text/format-compile.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,101 @@
+define(
+ [],
+ function() {
+ var map = {
+ "\\{" : "&curlopen;",
+ "\\}" : "&curlclose;",
+ "&" : "&",
+ "\\:" : ":"
+ };
+
+ var rev = {
+ curlopen : "{",
+ curlclose : "}",
+ amp : "&",
+ colon : ":"
+ };
+
+ var espaceString = function(s) {
+ if (!s)
+ return s;
+ return "'" + s.replace(/('|\\)/g, "\\$1") + "'";
+ };
+
+ var encode = function(s) {
+ if (!s)
+ return s;
+ return s.replace(/\\{|\\}|&|\\:/g, function(m) {
+ return map[m] || m;
+ });
+ };
+
+ var decode = function(s) {
+ if (!s)
+ return s;
+ return s.replace(/&(\w+);/g, function(m, $1) {
+ return rev[$1] || m;
+ });
+ };
+
+ var subst = function(s) {
+ var i = s.indexOf(":"), name, pattern;
+ if (i >= 0) {
+ name = s.substr(0, i);
+ pattern = s.substr(i + 1);
+ } else {
+ name = s;
+ }
+
+ if (pattern)
+ return [
+ espaceString(decode(name)),
+ espaceString(decode(pattern)) ];
+ else
+ return [ espaceString(decode(name)) ];
+ };
+
+ var compile = function(str) {
+ if (!str)
+ return function() {};
+
+ var chunks = encode(str).split("{"), chunk;
+
+ var code = [ "var result=[];" ];
+
+ for (var i = 0; i < chunks.length; i++) {
+ chunk = chunks[i];
+
+ if (i === 0) {
+ if (chunk)
+ code.push("result.push(" + espaceString(decode(chunk)) +
+ ");");
+ } else {
+ var len = chunk.indexOf("}");
+ if (len < 0)
+ throw new Error("Unbalanced substitution #" + i);
+
+ code.push("result.push(subst(" +
+ subst(chunk.substr(0, len)).join(",") + "));");
+ if (chunk.length > len + 1)
+ code.push("result.push(" +
+ espaceString(decode(chunk.substr(len + 1))) + ");");
+ }
+ }
+
+ code.push("return result.join('');");
+
+ /* jshint -W054 */
+ return new Function("subst", code.join("\n"));
+ };
+
+ var cache = {};
+
+ return function(template) {
+ var compiled = cache[template];
+ if (!compiled) {
+ compiled = compile(template);
+ cache[template] = compiled;
+ }
+ return compiled;
+ };
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/text/format.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/text/format.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,87 @@
+define([
+ "../safe",
+ "./format-compile",
+ "dojo/number",
+ "dojo/date/locale",
+ "dojo/_base/array" ], function(safe, compile, number, date, array) {
+
+ // {short,medium,full,long}-{date,time}
+ var convert = function(value, pattern) {
+ if (!pattern)
+ return value.toString();
+
+ if (pattern.toLocaleLowerCase() == "json") {
+ var cache = [];
+ return JSON.stringify(value, function(k, v) {
+ if (!safe.isPrimitive(v)) {
+ var id = array.indexOf(cache, v);
+ if (id >= 0)
+ return "@ref-" + id;
+ else
+ return v;
+ } else {
+ return v;
+ }
+ },2);
+ }
+
+ if (safe.isNumber(value)) {
+ var nopt = {};
+ if (pattern.indexOf("!") === 0) {
+ nopt.round = -1;
+ pattern = pattern.substr(1);
+ }
+ nopt.pattern = pattern;
+ return number.format(value, nopt);
+ } else if (value instanceof Date) {
+ var m = pattern.match(/^(\w+)-(\w+)$/);
+ if (m)
+ return date.format(value, {
+ selector : m[2],
+ formatLength : m[1]
+ });
+ else if (pattern == "iso")
+ return value.toISOString();
+ else
+ return date.format(value, {
+ selector : "date",
+ datePattern : pattern
+ });
+ } else {
+ return value.toString(pattern);
+ }
+ };
+
+ function formatter(format) {
+ var data;
+
+ if (arguments.length <= 1)
+ return format;
+
+ data = Array.prototype.slice.call(arguments, 1);
+
+ var template = compile(format);
+
+ return template(function(name, pattern) {
+ var value = data[name];
+ return !safe.isNull(value) ? convert(value, pattern) : "";
+ });
+ }
+
+ formatter.compile = function(format) {
+ var template = compile(format);
+
+ return function() {
+ var data = arguments;
+
+ return template(function(name, pattern) {
+ var value = data[name];
+ return !safe.isNull(value) ? convert(value, pattern) : "";
+ });
+ };
+ };
+
+ formatter.convert = convert;
+
+ return formatter;
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 core/src/js/text/template-compile.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/src/js/text/template-compile.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,134 @@
+define(
+ ["dojo/request", "./format", "../log/trace!"],
+ function (request, format, trace) {
+
+ // разбивает строку шаблона на токены, возвращает контекст для
+ // дальнейшей обработки в visitTemplate
+ var parseTemplate = function (str) {
+ var tokens = str.split(/(<%=|\[%=|<%|\[%|%\]|%>)/);
+ var pos = -1;
+ var data = [],
+ code = [];
+
+ return {
+ next: function () {
+ pos++;
+ return pos < tokens.length;
+ },
+ token: function () {
+ return tokens[pos];
+ },
+ pushData: function () {
+ var i = data.length;
+ data.push.apply(data, arguments);
+ return i;
+ },
+ pushCode : function() {
+ var i = code.length;
+ code.push.apply(code, arguments);
+ return i;
+ },
+ compile: function () {
+ var text = "var $p = [];\n" +
+ "var print = function(){\n" +
+ " $p.push(format.apply(null,arguments));\n" +
+ "};\n" +
+ // Introduce the data as local variables using with(){}
+ "with(obj){\n" +
+ code.join("\n") +
+ "}\n" +
+ "return $p.join('');";
+
+ try {
+ var compiled = new Function("obj, format, $data", text);
+ /**
+ * Функция форматирования по шаблону
+ *
+ * @type{Function}
+ * @param{Object} obj объект с параметрами для подстановки
+ */
+ return function (obj) {
+ return compiled(obj || {}, format, data);
+ };
+ } catch (e) {
+ trace.error([e]);
+ trace.log([text, data]);
+ throw e;
+ }
+ }
+ }
+ };
+
+ function visitTemplate(context) {
+ while (context.next()) {
+ switch (context.token()) {
+ case "<%":
+ case "[%":
+ visitCode(context);
+ break;
+ case "<%=":
+ case "[%=":
+ visitInline(context);
+ break;
+ default:
+ visitTextFragment(context);
+ break;
+ }
+ }
+ }
+
+ function visitInline(context) {
+ var code = ["$p.push("];
+ while (context.next()) {
+ if (context.token() == "%>" || context.token() == "%]")
+ break;
+ code.push(context.token());
+ }
+ code.push(");");
+ context.pushCode(code.join(''));
+ }
+
+ function visitCode(context) {
+ var code = [];
+ while (context.next()) {
+ if (context.token() == "%>" || context.token() == "%]")
+ break;
+ code.push(context.token());
+ }
+ context.pushCode(code.join(''));
+ }
+
+ function visitTextFragment(context) {
+ var i = context.pushData(context.token());
+ context.pushCode("$p.push($data["+i+"]);");
+ }
+
+ var compile = function (str) {
+ if (!str)
+ return function() { return "";};
+
+ var ctx = parseTemplate(str);
+ visitTemplate(ctx);
+ return ctx.compile();
+ };
+
+ var cache = {};
+
+ compile.load = function (id, require, callback) {
+ var url = require.toUrl(id);
+ if (url in cache) {
+ callback(cache[url]);
+ } else {
+ request(url).then(compile).then(function (tc) {
+ callback(cache[url] = tc);
+ }, function (err) {
+ require.signal("error", [{
+ error: err,
+ src: 'implab/text/template-compile'
+ }]);
+ });
+ }
+ };
+
+ return compile;
+ });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 dom/.project
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/.project Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,17 @@
+
+
+ dom
+ Project dom created by Buildship.
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectbuilder
+
+
+
+
+
+ org.eclipse.buildship.core.gradleprojectnature
+
+
diff -r d796bbbe558c -r acdcdf1a8d21 dom/.settings/org.eclipse.buildship.core.prefs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/.settings/org.eclipse.buildship.core.prefs Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,2 @@
+connection.project.dir=..
+eclipse.preferences.version=1
diff -r d796bbbe558c -r acdcdf1a8d21 dom/build.gradle
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/build.gradle Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,2 @@
+task build(type: Copy) {
+}
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 dom/package.json
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/package.json Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,18 @@
+{
+ "name": "@implab/dom",
+ "version": "1.0.1",
+ "description": "Dependency injection, logging, simple and fast text template engine",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": [
+ "di",
+ "ioc",
+ "logging",
+ "template engine",
+ "dependency injection"
+ ],
+ "author": "Sergey Smirnov",
+ "license": "MIT"
+}
diff -r d796bbbe558c -r acdcdf1a8d21 dom/src/js/css.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/src/js/css.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,10 @@
+define(["./inject"], function (inject) {
+ return {
+ load: function (id, require, cb) {
+ var url = require.toUrl(id);
+ inject.injectStylesheet(url).then(function () {
+ cb();
+ });
+ }
+ };
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 dom/src/js/inject.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/src/js/inject.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,86 @@
+define(["../Deferred", "../log/trace!"], function (Deferred, trace) {
+ function on(node, eventName, handler) {
+ // Add an event listener to a DOM node
+ node.addEventListener(eventName, handler, false);
+
+ return function () {
+ node.removeEventListener(eventName, handler, false);
+ };
+ }
+
+ return {
+ injectionPoint: document.head,
+ injectBefore: document.head.firstChild,
+
+ _map: {},
+
+ _inject: function (name, attr) {
+ var node = document.createElement(name),
+ d = new Deferred(),
+
+ cleanup = function () {
+ noerr();
+ noload();
+ },
+
+ noload = on(node, "load", function () {
+ d.resolve({
+ node: node
+ });
+ cleanup();
+ }, true),
+
+ noerr = on(node, "error", function (e) {
+ d.reject({
+ erorr: e,
+ node: node
+ });
+ cleanup();
+ }, true);
+
+ for (var p in attr)
+ node[p] = attr[p];
+
+ this.injectionPoint.insertBefore(node, this.injectBefore);
+ return d;
+ },
+
+ injectScript: function (url) {
+ var d = this._map[url];
+ if (!d) {
+ trace.log("js {0}", url);
+ d = this._inject("script", {
+ type: "text/javascript",
+ charset: "utf-8",
+ src: url
+ });
+ d.then(function () {
+ trace.log("done {0}", url);
+ }, function (e) {
+ trace.err([url, e]);
+ });
+ this._map[url] = d;
+ }
+ return d;
+ },
+
+ injectStylesheet: function (url) {
+ var d = this._map[url];
+ if (!d) {
+ trace.log("css {0}", url);
+ d = this._inject("link", {
+ type: "text/css",
+ rel: "stylesheet",
+ href: url
+ });
+ d.then(function () {
+ trace.log("done {0}", url);
+ }, function (e) {
+ trace.error([url, e]);
+ });
+ this._map[url] = d;
+ }
+ return d;
+ }
+ };
+});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 npm/implab/index.js
--- a/npm/implab/index.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-/**
- * Created by internet on 6/21/16.
- */
-'user strict';
-/*=====
- return {
- // summary:
- // The implab package main module; implab package is somewhat unusual in that the main module currently just provides an empty object.
- // Apps should require modules from the implab packages directly, rather than loading this module.
- };
- =====*/
-
-/**
- The entry point
- @module implab
- */
-
-module.exports = {};
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 npm/implab/package.json
--- a/npm/implab/package.json Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-{
- "name": "implab",
- "version": "1.0.1",
- "description": "Dependency injection, logging, simple and fast text template engine",
- "main": "index.js",
- "scripts": {
- "test": "echo \"Error: no test specified\" && exit 1"
- },
- "keywords": [
- "di",
- "ioc",
- "logging",
- "template engine",
- "dependency injection"
- ],
- "author": "Sergey Smirnov",
- "license": "MIT"
-}
diff -r d796bbbe558c -r acdcdf1a8d21 settings.gradle
--- a/settings.gradle Sat Jun 23 21:50:11 2018 +0300
+++ b/settings.gradle Tue Jun 26 19:35:44 2018 +0300
@@ -12,4 +12,7 @@
//include 'sub-project-name'
+include 'core'
+include 'dom'
+
rootProject.name = 'implab'
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/BaseLayer.js
--- a/src/djol/BaseLayer.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-define([
- "implab/text/template-compile",
- "dojo/_base/declare",
- "dojo/_base/lang",
- "ol"],
- function (compile, declare, lang, ol) {
- return declare([ol.layer.Layer], {
-
- name: null,
-
- displayName: null,
-
- identifyResultTemplate: null,
-
- searchResultTemplate: null,
-
- constructor: function () {
- lang.mixin(this, arguments[0]);
- var identifyCompiledTemplate = null, searchCompiledTemplate = null;
- if (this.identifyResultTemplate) {
- identifyCompiledTemplate = compile(this.identifyResultTemplate);
- }
- if (this.searchResultTemplate) {
- searchCompiledTemplate = compile(this.searchResultTemplate);
- }
- },
-
- /** Возвращает массив строк, каждая строка - результат поиска приведенный к шаблонному виду
- @options {Object}
- @str {String} поисковая строка
- @bbox {Object} bound box, в рамках которого осуществлять поиск
- */
- getSearchResult: function (options) {
- console.warn("Метод необходимо переопределить для для слоя конкретного типа!");
- },
- /** Возвращает массив строк, каждая строка - результат идентификации приведенный к шаблонному виду
- @options {Object}
- @coordinates {Array} массив описывающий координаты точки идентификации
- */
- getItentifyResult: function (coordinates) {
- console.warn("Метод необходимо переопределить для для слоя конкретного типа!");
- }
- });
- })
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ClearTool.js
--- a/src/djol/ClearTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-define (["dojo/_base/declare", "./_OneshotTool", "implab/safe"] , function(declare, _OneshotTool, safe) {
- return declare([_OneshotTool], {
- tools : null,
-
- constructor : function(opts) {
- safe.mixin(this,opts, ["tools"]);
- },
-
- invoke : function() {
- if (this.tools) {
- this.log("Clear {0} tools", this.tools.length);
- safe.each(this.tools, function(tool) {
- if (tool.clear)
- tool.clear();
- });
- }
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/CoordPickerTool.js
--- a/src/djol/CoordPickerTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,24 +0,0 @@
-define (["dojo/_base/declare", "./_OneshotTool", "implab/safe", "dojo/when"] , function(declare, _OneshotTool, safe, when) {
- return declare([_OneshotTool], {
- _map : null,
- _proj : null,
-
- constructor : function(opts) {
- safe.argumentNotNull(opts && opts.map, "opts.map");
-
- this._map = opts.map;
- this._proj = opts.proj;
- },
-
- invoke : function() {
- var me = this;
-
- return when(me._map.awaitMapEvent('singleclick'), function(evt){
- if (me._proj) {
- // тут можно преобразовать проекции
- }
- return evt;
- });
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/DeactivationTool.js
--- a/src/djol/DeactivationTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-define(["dojo/_base/declare", "./_ToolBase"],function(declare, _ToolBase) {
-
- // Инструмент, выключает текущий активный инструмент
- // Данный инструмент ничго не делает, но при его активации будет
- // деактивирован предыдущий инструмент
- return declare([_ToolBase], {
-
- // данный инструмент не может быть активным, поэтому данный метод
- // переопределяется и возвращает всегда false
- onActivating : function() {
- return false;
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/DistanceMeasureTool.js
--- a/src/djol/DistanceMeasureTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-define([
- "dojo/_base/declare",
- "implab/safe",
- "./MeasureToolBase",
- "implab/text/format",
- "dojo/i18n!./format/nls/units",
- "ol" ],
-
-function(declare, safe, MeasureToolBase, format, units, ol) {
- return declare([ MeasureToolBase ], {
-
- isGeodesic : true,
-
- units : 'metric',
-
- constructor : function(opts) {
- if (opts)
- safe.mixin(this,opts,["isGeodesic", "units"]);
- },
-
- _createDraw : function(source) {
- return new ol.interaction.Draw(
- {
- source : source,
- type : "LineString",
- style : this.drawStyle
- });
- },
-
- _formatTooltip : function(sketch, proj) {
- var length = 0;
- if (this.isGeodesic) {
- var points = sketch.getGeometry().getCoordinates();
- var t = ol.proj.getTransform(proj, "EPSG:4326");
- for (var i = 0; i < points.length - 1; i++) {
- length += this.wgs84Sphere.haversineDistance(
- t(points[i]),
- t(points[i + 1]));
- }
- } else {
- length = sketch.getGeometry().getLength();
- }
-
- var mpu, unitName;
- switch (this.units) {
- case "nautical":
- mpu = 1852;
- unitName = units.nmiles;
- break;
- default:
- mpu = 1000;
- unitName = units.kilometers;
- }
-
- if (length >= mpu) {
- return format("{0:#.0#}{1}", length / mpu, unitName);
- } else {
- return format("{0:#0.0#}{1}", length, units.meters);
- }
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/DynamicStyle.js
--- a/src/djol/DynamicStyle.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,119 +0,0 @@
-define([ "./declare-style", "dojo/_base/declare", "ol", "implab/safe" ],
-
-function(declare, dojoDeclare, ol, safe) {
- return declare([], {
- _cache : null,
- _getKey : null,
- _getZoom : null,
-
- defaultStyle : null,
-
- style : null,
-
- styleFunction : null,
-
- filter : null,
-
- constructor : function(opts) {
- if (opts)
- dojoDeclare.safeMixin(this, opts);
-
- this._cache = {};
-
- if (this.zoom) {
- if (this.zoom instanceof Function) {
- this._getZoom = this.zoom;
- } else {
- var levels = [], max = "max";
- for ( var p in this.zoom) {
- if (safe.isNumber(this.zoom[p]))
- levels.push({
- name : p,
- zoom : Number(this.zoom[p])
- });
- else if (this.zoom[p] == "max")
- max = p;
- }
-
- levels.sort(function(x, y) {
- return x.zoom - y.zoom;
- });
-
- this.zoomMax = max;
- this.zoomLevels = levels;
-
- this._getZoom = function(z) {
- for (var i = 0; i < levels.length; i++) {
- if (z <= levels[i].zoom)
- return levels[i].name;
- }
- return max;
- };
- }
- } else {
- this._getZoom = function(z) {
- return "max";
- };
- }
-
- if (this.key) {
- if (this.key instanceof Function) {
- this._getKey = this.key;
- } else if (typeof this.key === "string") {
- this._getKey = function(ft) {
- return ft.get(this.key);
- };
- } else {
- this._getKey = function(ft, z) {
- var k = this.key[z];
- if (k instanceof Function)
- return k.call(this, ft, z);
- else if (typeof k == "string")
- return ft.get(k);
- else
- return this.defaultStyle;
- };
- }
- } else {
- this._getKey = function() {
- return this.defaultStyle;
- };
- }
-
- if (this.style) {
- if (this.style instanceof Function) {
- this._style = this.style;
- } else {
- this._style = function(ft, res, key, zoom) {
- var s = this.style[zoom];
- return s && (s instanceof Function) ? s.apply(
- this,
- arguments) : s;
- };
- }
- }
- },
-
- getFeatureStyle : function(ft, res) {
- safe.argumentNotNull(ft, "ft");
-
- if (this.filter && this.filter(ft) === false)
- return null;
-
- var z = this._getZoom(res);
- var k = this._getKey(ft, z);
-
- var cid = [ k, z ].join('-');
-
- var style = this._cache[cid];
- if (!style) {
- style = this._style ? this._style(ft, res, k, z) : null;
- this._cache[cid] = style;
- }
-
-
- return safe.isNull(style) || style instanceof Array ? style : [ style ];
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/IdentificationTool.js
--- a/src/djol/IdentificationTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,246 +0,0 @@
-define([
- "dijit/layout/ContentPane",
- "dojo/_base/declare",
- "dojo/Deferred",
- "dojo/dom-construct",
- "dojo/dom-class",
- "dojo/on",
- "dojo/promise/all",
- "dojo/when",
- "implab/safe",
- "ol",
- "./listen",
- "./IdentifyGroup",
- "./_ToolBase",
- "./PopupContainer"
- ],
-
- function (
- ContentPane,
- declare,
- Deffered,
- domConstruct,
- domClass,
- on,
- promiseAll,
- when,
- safe,
- ol,
- listen,
- IdentifyGroup,
- _ToolBase,
- PopupContainer) {
- return declare([_ToolBase], {
- /**
- * массив обработчиков openLayers, которые необходимо удалить при
- * деактивации
- */
- _handlers: null,
- /**
- * widget карты
- */
- _map: null,
- /**
- * openLayers map
- */
- _olMap: null,
- /**
- * Массив overlays содержащих popupContainers
- */
- _popupOverlays: null,
- /**
- * Массив popups контейнеров
- */
- _popupContainers: null,
- /**
- * Режим работы инструмента идентификации
- *
- * @value {String} "single"||"multiple"
- */
- mode: null,
- /**
- * Режимы
- */
- appManager: null,
-
- constructor: function (options) {
- safe.argumentNotNull(options, "options");
- safe.argumentNotNull(options.map, "options.map");
- safe.argumentNotNull(options.appManager, "options.appManager");
-
- this._map = options.map;
- this._olMap = options.map.olMap;
- this._popupContainers = [];
- this._popupOverlays = [];
- this._handlers = [];
-
- this.appManager = options.appManager;
- this.mode = options.mode || "single";
- },
- /**
- */
- createPopupContent: function (groupWidgets) {
- var contentWidget = new ContentPane();
- groupWidgets.forEach(function (groupWidget) {
- if (groupWidget && !groupWidget.isEmpty()) {
- contentWidget.addChild(groupWidget);
- }
- });
- return contentWidget;
- },
-
- /**
- * Возвращает обещание на получение объекта с результатом идентификации
- * по всем видимым режимам и информационным слоям @ options {Object} @ pixel
- * {Object} - информация о точке идентификации @ coordinate {Array} -
- * координаты точки иденификации
- */
- getGroupsFromVisibleModules: function (options) {
- var promises = [];
- var modules = this.appManager.getVisibleModules();
- modules.forEach(function (module) {
- promises.push.apply(promises, module
- .getIdentifyResult(options));
- });
-
- return promiseAll(promises).then(
- function (results) {
- console.log("promise all groups = ", results);
- return results;
- });
- },
-
- identifyPosition: function (position) {
- var me = this, i;
- var popupContainer = null,
- popupOverlay = null;
- if (me.mode == "multiple") {
- // TODO: создать popupContainer и popupOverlay
- popupContainer = new PopupContainer({
- map: me._olMap
- });
- on(popupContainer, "close", function () {
- var index = me._popupContainers.indexOf(me);
- me._popupContainers.splice(index, 1);
-
- });
- me._popupContainers.push(popupContainer);
-
- popupOverlay = new ol.Overlay({
- element: popupContainer.domNode,
- autoPan: true,
- autoPanAnimation: {
- duration: 250
- }
- });
- me._popupOverlays.push(popupOverlay);
- me._olMap.addOverlay(popupOverlay);
-
- } else {
- if (me._popupContainers.length > 0) {
- // Берем первый
- popupContainer = me._popupContainers[0];
- // Все остальные удалить
- if (me._popupContainers.length > 1) {
- for (i = 1; i < me._popupContainers.length; i++) {
- me._popupContainers[i].destroyRecursive();
- }
- me._popupContainers.splice(
- 1,
- me._popupContainers.length - 1);
- }
- } else {
- // Создаем новый
- popupContainer = new PopupContainer({
- map: me._olMap
- });
- on(popupContainer, "close", function () {
- var index = me._popupContainers.indexOf(me);
- me._popupContainers.splice(index, 1);
-
- });
- me._popupContainers.push(popupContainer);
- }
- if (me._popupOverlays.length > 0) {
- // Берем первый и помещаем в него popup
- popupOverlay = me._popupOverlays[0];
- popupOverlay.setElement(popupContainer.domNode);
- // Все остальные удалить
- if (me._popupOverlays.length > 1) {
- for (i = 1; i < me._popupOverlays.length; i++) {
- me._olMap.removeOverlay(me._popupOverlays[i]);
- }
- me._popupOverlays.splice(
- 1,
- me._popupOverlays.length - 1)
- }
- } else {
- // Создаем новый и помещаем в него popup
- popupOverlay = new ol.Overlay({
- element: popupContainer.domNode,
- autoPan: true,
- autoPanAnimation: {
- duration: 250
- }
- });
- me._popupOverlays.push(popupOverlay);
- me._olMap.addOverlay(popupOverlay);
- }
- }
-
- popupContainer.destroyDescendants();
-
- popupOverlay.setPosition(position.coordinate);
-
- popupContainer.showOverlay();
-
- when(me.getGroupsFromVisibleModules(position), function (data) {
- var contentWidget = me.createPopupContent(data);
- popupContainer.show(contentWidget, "only");
- popupContainer.hideOverlay();
- });
- },
- /**
- * Скрыть все popups
- */
- hideAllPopups: function () {
- var me = this, i;
- for (i = 0; i < this._popupContainers.length; i++) {
- this._popupContainers[i].destroyRecursive();
- }
- this._popupContainers.splice(0, this._popupContainers.length);
-
- for (i = 0; i < this._popupOverlays.length; i++) {
- this._olMap.removeOverlay(this._popupOverlays[i]);
- }
- this._popupOverlays.splice(0, this._popupOverlays.length)
- },
-
- onActivating: function () {
- var me = this;
- // Обработчик для события "singleclick" по карте
- var handler = listen(this._olMap, 'singleclick', function (evt) {
- if (evt.originalEvent.ctrlKey) {
- me.mode = "multiple";
- } else {
- me.mode = "single";
- }
- me.identifyPosition({
- pixel: evt.pixel,
- coordinate: evt.coordinate
- });
- });
- this._handlers.push(handler);
- },
-
- onDeactivating: function () {
- var me = this;
- me._handlers.forEach(function (handler) {
- if (handler.remove)
- handler.remove();
-
- });
- this.hideAllPopups();
- },
- })
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/IdentifyGroup.js
--- a/src/djol/IdentifyGroup.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-define(
- [
- "implab/safe",
- 'dijit/_WidgetBase',
- 'dijit/_TemplatedMixin',
- "dijit/_WidgetsInTemplateMixin",
- "dijit/layout/_LayoutWidget",
- "dijit/layout/ContentPane",
- "dojo/_base/declare",
- "dojo/dom-construct",
- "dojo/on",
- "ol3/IdentifyItem" ],
- function(
- safe,
- _WidgetBase,
- _TemplatedMixin,
- _WidgetsInTemplateMixin,
- _LayoutWidget,
- ContentPane,
- declare,
- domConstruct,
- on,
- IdentifyItem) {
-
- return declare(
- [ _LayoutWidget, _TemplatedMixin, _WidgetsInTemplateMixin ],
- {
-
- /**
- */
- _empty : true,
- /**
- */
- layerName : null,
- /**
- * Шаблон всего widget
- */
- templateString : "
",
-
- itemTemplate : "",
-
- title : null,
-
- /**
- * Метод из widget.lifecycle
- */
- postCreate : function() {
- var me = this;
- if (typeof this.title == "string") {
- this.identifyItemGroupTitle.innerHTML = me.title;
- } else if (me.title && me.title.placeAt) {
- me.title.placeAt(me.identifyItemGroupTitle, "only");
- } else {
- domConstruct.place(
- me.title,
- me.identifyItemGroupTitle,
- "only");
- }
- on(this.domNode, "click", function() {
- if ("function" == typeof me.callback) {
- me.callback();
- }
- });
- },
-
- addItem : function(options) {
- safe.argumentNotNull(options, "options");
- safe.argumentNotNull(options.model, "options.model");
-
- if (options.model) {
-
- var item = new IdentifyItem({
- title : options.title || this.itemTemplate,
- model : options.model,
- callback : options.callback
- });
- this.addChild(item);
- this._empty = false;
- } else {
- console
- .error("Не задано необходимое свойство layerFeature");
- }
- },
-
- isEmpty : function() {
- return this._empty;
- }
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/IdentifyItem.js
--- a/src/djol/IdentifyItem.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-define([
- 'dijit/_WidgetBase',
- 'dijit/_TemplatedMixin',
- "dijit/Tooltip",
- "dojo/_base/declare",
- "dojo/date/locale",
- "dojo/dom-construct",
- "dojo/on" ], function(_WidgetBase, _TemplatedMixin, Tooltip, declare,
- dateLocale, domConstruct, on) {
- var empty = {};
- return declare([ _WidgetBase, _TemplatedMixin ], {
-
- callback : null,
-
- dateLocale : dateLocale,
-
- baseClass : 'identify-item',
-
- feature : null,
-
- model : empty,
-
- title : null,
-
- templateString : "",
-
- constructor : function(options) {
- option = options || {};
- if (options.title)
- this.title = options.title;
- if (options.model)
- this.model = options.model;
- if (options.callback)
- this.callback = options.callback;
-
- },
-
- /**
- * Метод из widget.lifecycle
- */
- postCreate : function() {
- var me = this;
-
- var content = me.title instanceof Function ? me.title(me)
- : me.title;
-
- if (typeof content == "string") {
- me.domNode.innerHTML = content;
- } else if (content && content.placeAt) {
- content.placeAt(me.domNode, "only");
- } else {
- domConstruct.place(content, me.domNode, "only");
- }
-
- on(me.domNode, "click", function() {
- if (typeof me.callback == "function") {
- me.callback(me.model);
- }
- });
- },
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ImageLayer.js
--- a/src/djol/ImageLayer.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["ol"], function(ol) {
- return ol.layer.Image
-})
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ImageWMSSource.js
--- a/src/djol/ImageWMSSource.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["ol"], function(ol) {
- return ol.source.ImageWMS;
-})
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/LayerCheckBox.js
--- a/src/djol/LayerCheckBox.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-define([
- "dojo/_base/declare",
- "dijit/_WidgetBase",
- "dijit/_TemplatedMixin",
- "dijit/_WidgetsInTemplateMixin",
- "dojo/text!./resources/LayerCheckBoxTemplate.html",
- "dijit/form/CheckBox" ], function(declare, _WidgetBase, _TemplatedMixin,
- _WidgetsInTemplateMixin, templateString) {
- return declare([ _WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin ], {
- templateString : templateString,
- labelNode : null,
- checkBox : null,
-
- label : "",
- _setLabelAttr : {
- node : "labelNode",
- type : "innerHTML"
- },
-
- name : "layer",
-
- _layer : null,
-
- constructor : function(options) {
- options = options || {};
-
- if (!options.layer)
- throw new Error("The layer is required");
-
- this._layer = options.layer;
- this.label = options.layer.get("label") || "unnamed";
- },
-
- postCreate : function() {
- var me = this;
- me.inherited(arguments);
-
- me.checkBox.set('name', me.name);
- me.checkBox.set('value', me._layer.getVisible());
- this.checkBox.on("change", function(value) {
- me._changed(value);
- });
- },
-
- _changed : function(visible) {
- this._layer.setVisible(visible);
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/LayerRadioButton.js
--- a/src/djol/LayerRadioButton.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-define([
- "dojo/_base/declare",
- "dijit/_WidgetBase",
- "dijit/_TemplatedMixin",
- "dijit/_WidgetsInTemplateMixin",
- "dojo/text!./resources/LayerRadioButtonTemplate.html",
- "dijit/form/RadioButton" ], function(declare, _WidgetBase, _TemplatedMixin,
- _WidgetsInTemplateMixin, templateString) {
- return declare([ _WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin ], {
- templateString : templateString,
-
- labelNode : null,
- radioButton : null,
-
- label : "",
- _setLabelAttr : {
- node : "labelNode",
- type : "innerHTML"
- },
-
- name : "layers",
-
- _layer : null,
-
- constructor : function(options) {
- options = options || {};
-
- if (!options.layer)
- throw new Error("The layer is required");
-
- this._layer = options.layer;
- this.label = options.layer.get("label") || "unnamed";
- },
-
- postCreate : function() {
- var me = this;
- me.inherited(arguments);
-
- me.radioButton.set('name', me.name);
- me.radioButton.set('value', me._layer.getVisible());
- this.radioButton.on("change", function(value) {
- me._changed(value);
- });
- },
-
- _changed : function(visible) {
- this._layer.setVisible(visible);
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/LayerSwitcher.js
--- a/src/djol/LayerSwitcher.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,81 +0,0 @@
-define([
- "dojo/_base/declare",
- "require",
- "dijit/_WidgetBase",
- "dijit/_TemplatedMixin",
- "dijit/_WidgetsInTemplateMixin",
- "dojo/text!./resources/LayerSwitcherTemplate.html",
- "./LayerCheckBox",
- "./LayerRadioButton",
- "app/view/Container" ],
-
-function(declare, require, _WidgetBase, _TemplatedMixin,
- _WidgetsInTemplateMixin, templateString, LayerCheckBox, LayerRadioButton) {
-
- return declare([ _WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin ], {
- templateString : templateString,
- requireScope : require,
- _layers : null,
- _map : null,
-
- infoLayersLabel : "Layers",
- _setInfoLayersLabelAttr : {
- node : "infoLayersLabelNode",
- type : "innerHTML"
- },
-
- baseLayersLabel : "Base",
- _setBaseLayersLabelAttr : {
- node : "baseLayersLabelNode",
- type : "innerHTML"
- },
-
- constructor : function(options) {
- options = options || {};
-
- if (!options.map)
- throw new Error("The map is required");
-
- this._map = options.map;
-
- if (options.layers && options.layers instanceof Array)
- this._layers = options.layers;
- else
- this._layers = [];
-
- // this.baseLayersLabel = "Base";
-
- },
-
- postCreate : function() {
- this.inherited(arguments);
-
- var pending = [];
-
- for ( var i in this._layers) {
- if (this._layers[i].get("layerType") != "base")
- pending.push(this._layers[i]);
- else
- this._addLayer(this._layers[i]);
- }
-
- for ( var i in pending)
- this._addLayer(pending[i]);
- },
-
- _addLayer : function(layer) {
- this._map.addLayer(layer);
-
- if (layer.get("layerType") === "base") {
- this.baseLayersContainer.addChild(new LayerRadioButton({
- layer : layer
- }));
- } else {
- this.infoLayersContainer.addChild(new LayerCheckBox({
- layer : layer
- }));
- }
- },
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/Map.js
--- a/src/djol/Map.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,176 +0,0 @@
-define([
- "dijit/registry",
- "dojo/_base/declare",
- "dijit/_WidgetBase",
- "dojo/dom-construct",
- "./PopupContainer",
- "dojo/_base/array",
- "ol",
- "ol3/listen",
- "dojo/Deferred",
- "implab/safe"
-], function (registry, declare, _WidgetBase, dom, PopupContainer, array, ol, listen, Deferred, safe) {
-
- return declare([_WidgetBase], {
- popupOverlays: null,
- olMap: null,
-
- _pending: null,
-
- constructor: function () {
- this._pending = {};
- },
-
- buildRendering: function () {
- this.domNode = dom.create("div");
- },
-
- postCreate: function () {
- this.inherited(arguments);
- this.popupOverlays = {};
- this.olMap = new ol.Map({
- target: this.domNode,
- layers: this.layers,
- view: this.view,
- controls: this.controls || [],
- });
- },
-
- getProjection : function() {
- return this.view.getProjection();
- },
-
- addInteraction: function (value) {
- this.olMap.addInteraction(value);
- },
-
- addLayer: function (layer) {
- if (layer) {
- if (layer.get("layerType") == "base")
- this.olMap.getLayers().insertAt(0, layer);
- else
- this.olMap.addLayer(layer);
- }
- },
-
- removeLayer: function(layer) {
- this.olMap.removeLayer(layer);
- },
-
- startup: function () {
- this.inherited(arguments);
-
- this.olMap.updateSize();
- },
-
- showPopup: function (contentWidget, position, opts) {
- // Скрыть popups указанной в opts.role роли, если (opts.hint ==
- // "replace")
- // Если не задан opts или opta.hint скрывать все popup
-
- var me = this;
-
- if ((!opts) || (!opts.hint)) {
- this.closeAllPopups();
- } else if ((opts.hint) && (opts.hint == "replace")) {
- if (opts.role) {
- this.closePopupsByRole(opts.role);
- } else {
- this.closeAllPopups();
- }
- }
- var overlay = new ol.Overlay({});
-
- if (opts && (opts.role)) {
- if (this.popupOverlays[opts.role]) {
- this.popupOverlays[opts.role].push(overlay);
- } else {
- this.popupOverlays[opts.role] = [overlay];
- }
- }
-
- // Отображение popUp start
- this.olMap.addOverlay(overlay);
- var popup = new PopupContainer({
- overlay: overlay,
- map: this.olMap,
- onClose: function () {
- // registry.byNode(overlay.getElement()).destroyRecursive();
- array.forEach(me.popupOverlays[opts.role], function (o) {
- if (o === overlay) {
- var index = me.popupOverlays[opts.role].indexOf(o);
- if (index > -1) {
- me.popupOverlays[opts.role].splice(index, 1);
- }
- }
- });
- }
- });
- overlay.setElement(popup.domNode);
- popup.show(contentWidget);
- overlay.setPosition(position);
- popup.hideOverlay();
- // end
- return popup;
- },
-
- closeAllPopups: function () {
- var overlays = this.olMap.getOverlays();
- overlays.forEach(function (elenemt, index) {
- registry.byNode(elenemt.getElement()).destroyRecursive();
- }, this);
- this.popupOverlays = {};
- },
-
- closePopupsByRole: function (role) {
- if (this.popupOverlays[role]) {
- array.forEach(this.popupOverlays[role], function (overlay) {
- registry.byNode(overlay.getElement()).destroyRecursive();
- });
- this.popupOverlays[role] = [];
- }
- },
-
- /**
- * Подписывается на событие карты
- *
- * @param {String}
- * name Имя события
- * @param {function(evt)}
- * filter Фильтр того, что событие нужное
- *
- * @returns {ol.ObjectEvent | ol.MapBroeserEvent | ol.MapEvent} Событие
- * на которое подписались.
- */
- awaitMapEvent: function (name, filter) {
- safe.argumentNotEmptyString(name, "name");
- var map = this.olMap,
- handle, d, me = this;
-
- if (me._pending[name])
- throw new Error("An event is already pending: " + name);
-
- me._pending[name] = d = new Deferred(function () {
- handle.remove();
- });
-
- handle = listen.once(map, name, function (evt) {
- if (!filter || filter(evt))
- d.resolve(evt);
- });
-
- return d.then(function (evt) {
- delete me._pending[name];
- return evt;
- }, function (err) {
- delete me._pending[name];
- throw err;
- });
- },
-
- cancelPendingEvents: function () {
- for (var name in this._pending)
- this._pending[name].cancel();
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/MeasureToolBase.js
--- a/src/djol/MeasureToolBase.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,181 +0,0 @@
-define([
- "dojo/_base/declare",
- "implab/safe",
- "ol",
- "./listen",
- "./_ToolBase",
- "dojo/dom-construct",
- "dojo/dom-class"
-], function (declare, safe, ol, listen, _ToolBase, dconstruct, dclass) {
- return declare([_ToolBase], {
- _draw: null,
-
- drawStyle: new ol.style.Style({
- fill: new ol.style.Fill({
- color: 'rgba(255, 255, 255, 0.2)'
- }),
- stroke: new ol.style.Stroke({
- color: 'rgba(230, 126, 34, 0.7)',
- lineDash: [10, 10],
- width: 2
- }),
- image: new ol.style.Circle({
- radius: 5,
- stroke: new ol.style.Stroke({
- color: 'rgba(0, 0, 0, 0.7)'
- }),
- fill: new ol.style.Fill({
- color: 'rgba(255, 255, 255, 0.2)'
- })
- })
- }),
-
- vectorStyle: new ol.style.Style({
- fill: new ol.style.Fill({
- color: 'rgba(255, 255, 255, 0.2)'
- }),
- stroke: new ol.style.Stroke({
- color: '#ffcc33',
- width: 2
- }),
- image: new ol.style.Circle({
- radius: 7,
- fill: new ol.style.Fill({
- color: '#ffcc33'
- })
- })
- }),
-
- _map: null,
-
- _olMap: null,
-
- _measureTooltipElement: null,
- /**
- * Overlay to show the measurement.
- *
- * @type {ol.Overlay}
- */
- _measureTooltip: null,
-
- _pointermoveKey: null,
-
- _sketch: null,
-
- _overlays: null,
-
- _vector: null,
-
- wgs84Sphere: new ol.Sphere(6378137),
-
- constructor: function (options) {
- safe.argumentNotNull(options, "options");
- safe.argumentNotNull(options.map, "map");
-
- this._map = options.map;
- this._olMap = options.map.olMap;
- this._overlays = [];
- },
-
- init: function () {
- if (this._draw)
- return;
-
- var source = new ol.source.Vector();
-
- this._vector = new ol.layer.Vector({
- source: source,
- style: this.vectorStyle
- });
- this._map.addLayer(this._vector);
-
- this._draw = this._createDraw(source);
- this._draw.on('drawstart', this._onDrawStart, this);
- this._draw.on('drawend', this._onDrawEnd, this);
-
- },
-
- onActivating: function () {
- this.init();
-
- this._pointermoveKey = listen(this._olMap, 'pointermove', safe.delegate(this, "_onPointerMove"));
- this._olMap.addInteraction(this._draw);
-
- return this.inherited(arguments);
- },
-
- onDeactivating: function () {
- // отключаем рисование и получение сообщений
- if (this._pointermoveKey)
- this._pointermoveKey.remove();
- this._olMap.removeInteraction(this._draw);
-
- // если был активен инструмент
- if (this._sketch) {
- // убиваем подсказку и сбрасываем текущее рисование
- this._sketch = null;
- this._measureTooltipElement = null;
- this._olMap.removeOverlay(this._measureTooltip);
- }
-
- return this.inherited(arguments);
- },
-
- clear: function () {
- var me = this;
- me.log("clear");
- if (me._vector) {
- me._vector.getSource().clear();
- me._overlays.forEach(function (x) {
- me._olMap.removeOverlay(x);
- });
- }
- },
-
- _createMeasureTooltip: function () {
- this._measureTooltipElement = dconstruct.create("div", {
- "class": 'tooltip poisk-measure-tooltip'
- });
- this._measureTooltip = new ol.Overlay({
- element: this._measureTooltipElement,
- offset: [0, -15],
- positioning: 'bottom-center'
- });
- this._olMap.addOverlay(this._measureTooltip);
-
- },
-
- _onDrawStart: function (evt) {
- this._sketch = evt.feature;
- this._createMeasureTooltip();
- },
-
- _onDrawEnd: function (evt) {
-
- this._measureTooltip.setOffset([0, -7]);
-
- dclass.remove(this._measureTooltipElement, "tooltip");
- dclass.add(this._measureTooltipElement, "tooltip-static");
-
- this._overlays.push(this._measureTooltip);
-
- this._sketch = null;
- this._measureTooltip = null;
- this._measureTooltipElement = null;
- },
-
- _onPointerMove: function (evt) {
- if (this._sketch && !evt.dragging) {
- this._measureTooltip.setPosition(evt.coordinate);
- this._measureTooltipElement.innerHTML = this._formatTooltip(
- this._sketch,
- this._olMap.getView().getProjection());
- }
- },
-
- _formatTooltip: function (sketch, proj) {
-
- }
- });
-
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/OSMSource.js
--- a/src/djol/OSMSource.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["ol"], function(ol) {
- return ol.source.OSM;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/OlTool.js
--- a/src/djol/OlTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,21 +0,0 @@
-define(["dojo/_base/declare", "dojo/_base/lang", "implab/safe", "dojo/dom-class", "dojo/dom-construct", "dijit/_TemplatedMixin", "dijit/_WidgetBase"],
- function (declare, lang, safe, domClass, domConstruct, _TemplatedMixin, _WidgetBase) {
- return declare([_WidgetBase, _TemplatedMixin], {
- map : null,
- control : null,
- elementName : "div",
-
- constructor: function () {
- lang.mixin(this, arguments[0]);
- safe.argumentNotNull(this.map, "map");
- safe.argumentNotNull(this.control, "control");
- },
-
- buildRendering : function() {
- this.domNode = domConstruct.create(this.elementName);
- domClass.add(this.domNode, this.baseClass);
- this.control.setTarget(this.domNode);
- this.control.setMap(this.map.olMap || this.map);
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/PopupContainer.js
--- a/src/djol/PopupContainer.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-define([
- "dijit/_WidgetBase",
- "dijit/_TemplatedMixin",
- "dijit/_WidgetsInTemplateMixin",
- "dijit/_Container",
- "dojo/_base/declare",
- "dojo/Evented",
- "dojo/dom-class",
- "dojo/on",
- "dojo/text!./resources/PopupContainerTemplate.html",
- "ol"
-],
- function (_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin, _Container, declare, Evented, domClass, on, templateString, ol) {
- return declare([_WidgetBase, _TemplatedMixin, _WidgetsInTemplateMixin, _Container/*, Evented*/], {
-
- templateString: templateString,
-
- overlay: null,
-
- map : null,
-
- constructor: function (options) {
- options = options || {};
- },
-
- postCreate: function () {
- var me = this;
- this.inherited(arguments);
- on(this.popupCloser, "click", function () {
- me.destroyRecursive();
- me.onClose();
- });
- },
-
- show: function (widget, opts) {
- opts = opts || "only";
- if (widget) {
- widget.placeAt(this.popupContent, opts);
- }
- },
-
- hideOverlay: function () {
- domClass.add(this.popupOverlay, "hidden")
- },
-
- showOverlay: function () {
- domClass.remove(this.popupOverlay, "hidden")
- },
-
- destroy : function() {
- this.map.removeOverlay(this.overlay);
- this.inherited(arguments);
- },
-
- onClose: function () {
- this.emit("close");
- }
-
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/SquareMeasureTool.js
--- a/src/djol/SquareMeasureTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-define([
- "dojo/_base/declare",
- "implab/safe",
- "./MeasureToolBase",
- "implab/text/format",
- "dojo/i18n!./format/nls/units",
- "ol" ],
-
-function(declare, safe, MeasureToolBase, format, units, ol) {
- return declare([ MeasureToolBase ], {
-
- isGeodesic : true,
-
- units : 'metric',
-
- constructor : function(opts) {
- if (opts)
- safe.mixin(this,opts,["isGeodesic", "units"]);
- },
-
- _createDraw : function(source) {
- return new ol.interaction.Draw({
- source : source,
- type : "Polygon",
- style : this.drawStyle
- });
- },
-
- _formatTooltip : function(sketch, proj) {
- var area;
- if (this.isGeodesic) {
- var geom = sketch.getGeometry().clone().transform(proj, 'EPSG:4326');
- var coordinates = geom.getLinearRing(0).getCoordinates();
- area = Math.abs(this.wgs84Sphere.geodesicArea(coordinates));
- } else {
- area = sketch.getGeometry().getArea();
- }
-
- var mpu, unitName;
- switch (this.units) {
- case "nautical":
- mpu = 1852*1852;
- unitName = units.nmiles2;
- break;
- default:
- mpu = 1852*1852;
- unitName = units.kilometers2;
- }
-
- if (area > mpu/10) {
- return format(
- "{0:#0.##} {1}",
- area / mpu,
- unitName);
- } else {
- return format("{0:#0.##} {1}", area, units.meters2);
- }
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/TileLayer.js
--- a/src/djol/TileLayer.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["ol"], function(ol) {
- return ol.layer.Tile;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/TileWMSSource.js
--- a/src/djol/TileWMSSource.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["ol"], function(ol) {
- return ol.source.TileWMS;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ToolBoxController.js
--- a/src/djol/ToolBoxController.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-define([
- "dojo/_base/declare",
- "implab/safe",
- "implab/components/ActivationController",
- "./ToolType" ],
-
-function(declare, safe, ActivationController, ToolType) {
- return declare([ ActivationController ], {
- _stack : null,
- _tools : null,
-
- constructor : function() {
- this._stack = new Array();
- this._tools = new Array();
- },
-
- activate : function(tool) {
- safe.argumentNotNull(tool, "tool");
-
- var me = this, current = me.getCurrent();
-
- return this.inherited(arguments).then(function(success) {
- if (success) {
- if (tool.toolType == ToolType.Oneshot && current)
- me._stack.push(current);
- else
- me._stack = [];
- }
- return success;
- });
- },
-
- deactivate : function() {
- var me = this;
- return me.inherited(arguments).then(function(success) {
- if (success && me._stack.length)
- return me.activate(me._stack.pop());
-
- return success;
- });
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ToolType.js
--- a/src/djol/ToolType.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-define([], function(){
- return {
- Activatable : 1,
- Oneshot : 2
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/VectorLayer.js
--- a/src/djol/VectorLayer.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +0,0 @@
-define([
- "implab/guard",
- "implab/text/template-compile",
- "dojo/_base/declare",
- "dojo/_base/lang",
- "dojo/Deferred",
- "ol"],
- function (guard, compile, declare, lang, Deferred, ol) {
- return declare([ol.layer.Vector], {
-
- map: null,
-
- _olMap: null,
-
- name: null,
-
- displayName: null,
-
- identifyResultTemplate: null,
-
- identifyCompiledTemplate:null,
-
- searchResultTemplate: null,
-
- searchCompiledTemplate: null,
-
- constructor: function () {
- lang.mixin(this, arguments[0]);
- this._olMap = this.map.olMap;
- var identifyCompiledTemplate = null, searchCompiledTemplate = null;
- if (this.identifyResultTemplate) {
- this.identifyCompiledTemplate = compile(this.identifyResultTemplate);
- }
- if (this.searchResultTemplate) {
- this.searchCompiledTemplate = compile(this.searchResultTemplate);
- }
- },
-
- /** Возвращает массив строк, каждая строка - результат поиска приведенный к шаблонному виду
- @options {Object}
- @str {String} поисковая строка
- @bbox {Object} bound box, в рамках которого осуществлять поиск
- */
- getSearchResult: function (options) {
- return null;
- },
-
- _getIdentifyResult: function (options) {
- var me = this;
- var features = [];
- //TODO: добавить фильтр по layer равный ему самому
- this._olMap.forEachFeatureAtPixel(options.pixel, function (feature, layer) {
- features.push({ feature: feature, layer: layer });
- }, null, function (layer) {
- return layer == me;
- });
- console.log(features);
- return features;
- },
- /** Возвращает массив строк, каждая строка - результат идентификации приведенный к шаблонному виду
- @options {Object}
- @coordinates {Array} массив описывающий координаты точки идентификации
- */
- getIdentifyResult: function (coordinates) {
- return guard(this, "_getIdentifyResult", [coordinates]);
- }
- });
- })
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/VectorStore.js
--- a/src/djol/VectorStore.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,289 +0,0 @@
-define(
- [
- "dojo/_base/declare",
- "dojo/_base/array",
- "implab/safe",
- "implab/Uuid",
- "ol",
- "ol3/listen",
- "./VectorStoreQuery",
- "dojo/store/util/QueryResults"
- ],
- function (declare, array, safe, UUID, ol, listen, VectorStoreQuery, QueryResults) {
- function createPaginator(opts) {
- return (opts.count || opts.start) &&
- function (results) {
- var total = results.length;
- results = results.slice(opts.start || 0, (opts.start || 0) +
- (opts.count || Infinity));
- results.total = total;
-
- return results;
- };
- }
-
- /**
- * Обертка вокруг векторного источника данных ol.source.Vector,
- * реализует dojo/store а также notify, что делает возможным наблюдение
- * за хранилищем при помощи dojo/store/Observable.
- *
- * @disposable
- */
- return declare(
- null, {
- _source: null, // ol3.source.Vector
-
- _projection: null,
-
- _subscriptions: null,
-
- constructor: function (opts) {
- safe.argumentNotNull(opts, "opts");
- safe.argumentOfType(
- opts.source,
- ol.source.Vector,
- "opts.source");
-
- var me = this;
-
- me._source = opts.source;
- if (opts.projection)
- me._projection = ol.proj.get(opts.projection);
- },
-
- getSource: function () {
- return this._source;
- },
-
- getProjection: function() {
- return this._projection;
- },
-
- get: function (id) {
- return this._source.getFeatureById(id);
- },
-
- /**
- * @param{Object|Function} q предикат для выбора объекта
- * @param{Object} opts параметры выполнения (start,count,sort)
- * @return{Function} filter(data) filter.matches
- * filter.matches.predicate
- * filter.matches.extent filter.sort
- * filter.sort.compare
- */
- queryEngine: function (q, opts) {
- opts = opts || {};
-
- // строим функцию для фильтрации
- var filter;
- if (q instanceof Function) {
- // если передали уже готовую функцию, испольуем ее
- filter = new VectorStoreQuery(q, q.extent);
- } else {
- // если передали объект
- var extent;
- // вытаскиваем из него extent
- if (q && 'extent' in q) {
- extent = q.extent;
- delete q.extent;
- }
-
- // строим новую функцию фильтрации
- filter = new VectorStoreQuery(q, extent);
- }
-
- // строим функцию сортировки
- var sort = opts.sort && this.sortEngine(opts.sort);
-
- var paginate = createPaginator(opts);
-
- // строим функцию выполнения запроса
- var execute = function (data) {
- var results = array.filter(data, filter);
-
- if (sort)
- sort(results);
-
- if (paginate)
- results = paginate(results);
- return results;
- };
-
- execute.matches = filter;
- execute.sort = sort;
- execute.paginate = paginate;
- return execute;
- },
-
- sortEngine: function (options) {
- var cmp = function (a, b) {
- for (var sort, i = 0;
- (sort = options[i]); i++) {
- var aValue = a.get(sort.attribute);
- var bValue = b.get(sort.attribute);
- if (aValue != bValue) {
- return Boolean(sort.descending) == aValue > bValue ? -1 : 1;
- }
- }
- return 0;
- };
-
- var execute = function (data) {
- return data.sort(cmp);
- };
-
- execute.compare = cmp;
- return execute;
- },
-
- /**
- * Запрашивает объекты со слоя
- *
- * @param{object|VectorStoreQuery|Function} query
- *
- *
- * {
- * extent : ol3.Extent,
- * }
- *
- */
- query: function (q, options) {
- var me = this;
- var filter = this.queryEngine(q, options);
-
- if (this.notify && !this.hasOwnProperty("_subscriptions")) {
- me._subscriptions = [];
-
- var sc = function (evt, handler) {
- me._subscriptions.push(listen(me._source, evt, safe.delegate(me, handler)));
- }
-
- sc("addfeature", "_onAdd");
- sc("changefeature", "_onUpdate");
- sc("removefeature", "_onRemove");
- }
-
- var predicate, data, extent = filter.matches &&
- filter.matches.extent;
- // если это запрос с указанием области
- if (extent) {
- predicate = filter.matches.predicate;
-
- data = this._source.getFeaturesInExtent(extent);
-
- if (predicate)
- data = array.filter(data, predicate);
-
- if (filter.sort)
- filter.sort(data);
-
- if (filter.paginate)
- data = filter.paginate(data);
- } else {
- // любой другой запрос
- data = filter(this._source.getFeatures());
- }
-
- return new QueryResults(data);
- },
-
- put: function (obj, options) {
- safe.argumentOfType(obj, ol.Feature, "obj");
- if (!options)
- options = {};
-
- if (options.id)
- obj.setId(options.id);
-
- var id = obj.getId() || new UUID();
-
- var prev = this.get(id);
-
- if ('overwrite' in options) {
- // overwrite=true указан, но перезаписывать нечего
- if (!prev && options.overwrite)
- throw new Error("The specified feature with id '" +
- id + "' doesn't exist in the store");
-
- // overwrite=false указан, но объект уже существует
- if (prev && !options.overwrite)
- throw new Error("The specified feature with id '" +
- id + "' already exists in the store");
- }
-
- // ok
- if (prev) {
- var data = obj.getProperties();
- prev.setProperties(data);
- } else {
- this._source.addFeature(obj);
- }
-
- return id;
- },
-
- add: function (obj, options) {
- safe.argumentOfType(obj, ol.Feature, "obj");
-
- if (!options)
- options = {};
-
- if (options.id)
- obj.setId(options.id);
-
- var id = obj.getId() || new UUID();
-
- var prev = this.get(id);
-
- if (prev)
- throw new Error("The specified feature with id '" + id +
- "' already exists in the store");
-
- this._source.addFeature(obj);
- },
-
- remove: function (id) {
- var me = this;
-
- var ft = me.get(id);
- if (ft)
- me._source.removeFeature(ft);
- },
-
- getIdentity: function (obj) {
- if (safe.isNull(obj))
- return undefined;
- if (!(obj instanceof ol.Feature))
- throw new Error("A feature is expected");
-
- return obj.getId();
- },
-
- _onAdd: function (ev) {
- this.notify(ev.feature);
- },
-
- _onRemove: function (ev) {
- var id = ev.feature.getId();
- if (!safe.isNull(id))
- this.notify(undefined, id);
- },
-
- _onUpdate: function (ev) {
- var id = ev.feature.getId();
- if (!safe.isNull(id))
- this.notify(ev.feature, id);
- },
-
- dispose: function () {
- var me = this;
- if (me._subscriptions)
- me._subscriptions.forEach(function (sc) {
- sc.remove();
- });
-
- me._source = null;
- me._subscriptions = null;
- }
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/VectorStoreQuery.js
--- a/src/djol/VectorStoreQuery.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-define([ "ol" ], function(ol) {
-
- function buildFilter(filter) {
- if (filter instanceof Function)
- return filter;
- if (filter) {
- var match = function(str) {
- return {
- test : function(x) {
- if (x === null || x === undefined)
- return false;
- return x.toString().startsWith(str);
- }
- };
- };
-
- for ( var p in filter) {
- if (typeof (filter[p]) == "string" && filter[p].endsWith("*"))
- filter[p] = match(filter[p].substr(0, filter[p].length));
- }
- return function(ft) {
- for ( var p in filter) {
- if (filter[p] && filter[p].test ? !filter[p]
- .test(ft.get(p)) : ft.get(p) != filter[p])
- return false;
- }
- return true;
- };
- }
- throw new Error("Unsupported filter");
- }
-
- /**
- * @constructor
- * @example
- *
- *
- * var store = new VectorStore({
- * source : vectorSource
- * });
- *
- * var req = new VectorStoreQuery({
- * city : "Moscow"
- * }, [ 30, 50, 40, 60 ]);
- *
- * store.query(req).then(showResults);
- *
- */
- return function(filter, extent) {
- var match = filter && buildFilter(filter);
-
- var query = function(ft) {
- if (extent) {
- var g = gt.getGeometry();
- if (!g || !ol.extent.intersects(extent, g.getExtent()))
- return false;
- }
-
- return !match || match(ft);
- };
-
- query.extent = extent;
- query.predicate = match;
-
- return query;
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/WFSSource.js
--- a/src/djol/WFSSource.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,123 +0,0 @@
-define([
- "ol",
- "dojo/request",
- "dojo/_base/array",
- "implab/safe",
- "implab/log/trace!"
-], function (ol,
- request,
- array,
- safe,
- trace
-) {
- return function (wfs, featurePrefix, featureType, featureNS, queryArgs) {
- if (arguments.length == 1) {
- featurePrefix = wfs.featurePrefix;
- featureType = wfs.featureType;
- featureNS = wfs.featureNS;
- wfs = wfs.wfsURL;
- queryArgs = wfs.queryArgs;
- }
-
- safe.argumentNotNull(wfs, "wfsURL");
- safe.argumentNotEmptyString(featurePrefix, "featurePrefix");
- safe.argumentNotEmptyString(featureNS, "featureNS");
- safe.argumentNotEmptyString(featureType, "featureType");
-
- var format = new ol.format.WFS({
- featureNS: featureNS,
- featureType: featureType
- });
-
- var layerName = featurePrefix + ":" + featureType;
-
- function loader(extent, resolution, projection) {
- var query = {
- service: 'WFS',
- version: '1.1.0',
- request: 'GetFeature',
- typename: layerName,
- srsname: projection.getCode()
- };
- safe.mixin(query, queryArgs);
-
- if (extent && isFinite(extent[0]))
- query.bbox = extent.join(',') + "," + projection.getCode();
-
- return request(wfs, {
- query: query,
- handleAs: 'xml'
- }).then(function (data) {
- // в загрузчике нельзя вызывать метод source.clear() поскольку
- // это приводит к рекурсии
- var features = format.readFeatures(data);
-
- var map = {},
- del = [],
- add = [];
-
- array.forEach(features, function (x) {
- // HACK исправляем идентификаторы, чтобы они совпадали с
- // реальными
-
- var id = x.get("id");
- if (id)
- x.setId(id);
- else
- id = x.getId();
-
- map[id] = x;
-
- // нужно проверить, была ли фича на карте
- var prev = source.getFeatureById(id);
- if (prev) {
- // если да, то обновить ее.
- var data = x.getProperties();
- prev.setProperties(data);
- } else {
- // иначе добавить
- add.push(x);
- }
- });
-
- source.forEachFeatureInExtent(extent, function (x) {
- if (!(x.getId() in map))
- del.push(x);
- });
-
- source.addFeatures(add);
-
- array.forEach(del, function (x) {
- source.removeFeature(x);
- });
-
- //revision = revision + 1;
-
- source.set("revision", ++revision);
-
- });
- }
-
- var cls = ol.source.ServerVector || ol.source.Vector;
- var revision = 0;
- var source = new cls({
- loader: loader,
- //revision: revision
- wrapX: false
- // ,
- // strategy : options.strategy || ol.loadingstrategy.all,
- // projection : options.projection
- });
- source.set("revision", revision);
- source.reload = function (extent, resolution, projection, q) {
- if (arguments.length >= 4)
- queryArgs = q;
- if (!extent)
- extent = [-Infinity, -Infinity, Infinity, Infinity];
- return loader(extent, resolution, projection);
- };
-
- trace.log("{0} -> {1}", layerName, wfs);
- return source;
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/_OneshotTool.js
--- a/src/djol/_OneshotTool.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-define(["dojo/_base/declare", "implab/safe", "implab/guard", "ol3/_ToolBase", "ol3/ToolType"],
-
- function (declare, safe, guard, _ToolBase, ToolType) {
- return declare([_ToolBase], {
- _pending: null,
-
- _lastResult: null,
-
- toolType: ToolType.Oneshot,
-
- invoke: function () {
- },
-
- onActivating: function () {
- var me = this;
-
- // start the operation
- me._lastResult = me._pending = guard(me, "invoke");
-
- return this.inherited(arguments);
- },
-
- onActivated: function () {
- var me = this;
-
- // fire the activate event
- this.inherited(arguments);
-
- me._pending.then(function () {
- if (me._pending) {
- me.log("Operation finished, deactivating.");
- me._pending = null;
- me.deactivate();
- }
- }, function (ex) {
- if (me._pending) {
- me.error("Operation failed, deactivating: {0}", ex);
- me._pending = null;
- me.deactivate();
- }
- });
- },
-
- onDeactivated: function () {
- var d = this._pending;
- if (d) {
- this.log("Cancelling pending operation");
- this._pending = null;
- d.cancel();
- }
-
- return this.inherited(arguments);
- },
-
- run: function () {
- var me = this;
-
- return me.activate().then(function () {
- return me._lastResult;
- });
- }
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/_ToolBase.js
--- a/src/djol/_ToolBase.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-define([
- "dojo/_base/declare",
- "dojo/when",
- "implab/safe",
- "implab/guard",
- "implab/components/_ActivatableMixin",
- "implab/log/_LogMixin",
- "dojo/Evented",
- "./ToolType" ],
-
-function(declare, when, safe, guard, _ActivatableMixin, _LogMixin, Evented, ToolType) {
- return declare([ _ActivatableMixin, Evented ], {
- toolType : ToolType.Activatable,
-
- module : null,
-
- constructor : function(opts) {
- if (opts) {
- if (opts.controller)
- this.setController(opts.controller);
- }
- },
-
- onActivating : function() {
- var me = this, inherited = this.getInherited(arguments);
- if (me.module && !me.module.isActive())
- return me.module.activate().then(function(active) {
- return active ? inherited.apply(me) : false;
- });
- else
- return inherited.apply(me);
- },
-
- onActivated : function() {
- this.emit("active", true);
- },
-
- onDeactivated : function() {
- this.emit("active", false);
- },
-
- destroy : function() {
-
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/declare-style.js
--- a/src/djol/declare-style.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-define(["dojo/_base/declare","implab/safe"],function(declare, safe){
- return function(base, proto){
- var cls = declare(base,proto);
-
- var factory = /** @this */ function() {
- var me = this;
- cls.apply(me,arguments);
- var fn = function() {
- return me.getFeatureStyle.apply(me,arguments);
- };
- fn.style = me;
- fn.styleFunction = fn;
- return fn;
- };
-
- factory.styleClass = cls;
- factory.prototype = cls.prototype;
- return factory;
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/format/coords.js
--- a/src/djol/format/coords.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-define(
- [ "dojo/i18n!./nls/coords", "implab/text/format", "implab/safe" ],
-
- function(nls, format, safe) {
-
- var formatDMS = function(coord) {
- return formatSD(coord, nls.dmsPattern);
- };
-
- var formatDM = function(coord) {
- return formatSD(coord, nls.dmPattern);
- };
-
- var formatD = function(coord) {
- return formatSD(coord, nls.dPattern);
- };
-
- /**
- * pattern:
- *
- * {0} - signed floating point number - latitude
- *
- * {1} - positive floating point number - minutes part of latitude
- *
- * {2} - positive floating point number - seconds part of latitude
- *
- * {3} - localized hemisphere sign: north or south
- *
- * {4} - signed floating point number - longitude
- *
- * {5} - positive floating point number - minutes part of longitude
- *
- * {6} - positive floating point number - seconds part of longitude
- *
- * {7} - localized hemisphere sign: east or west
- */
- var formatSD = function(coord, pattern) {
- safe.argumentNotNull(coord, "coord");
- if (!pattern)
- pattern = nls.sdPattern;
- var x = (coord[0] % 360 + 540) % 360 - 180, y = (coord[1] % 180 + 270) % 180 - 90;
-
- return format(pattern, y, Math.abs((y * 60) % 60), Math
- .abs((y * 3600) % 60), y >= 0 ? nls.north : nls.south, x, Math
- .abs((x * 60) % 60), Math.abs((x * 3600) % 60), x >= 0
- ? nls.east
- : nls.west);
- };
-
- var cls = function(fmt) {
- switch (fmt) {
- case "DMS":
- return formatDMS;
- case "DM":
- return formatDM;
- case "D":
- return formatD;
- case "SD":
- return formatSD;
- default:
- if (!fmt)
- return formatSD;
- else
- return function(coord) {
- return formatSD(coord, fmt);
- }
- }
- };
-
- return cls;
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/format/nls/coords.js
--- a/src/djol/format/nls/coords.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-define({
- root : {
- // lat lon
- dmsPattern : "{0:!00;00}\u00b0{1:!00}\u2032{2:00}\u2033{3} {4:!000;000}\u00b0{5:!00}\u2032{6:00}\u2033{7}",
- dmPattern : "{0:!00;00}\u00b0{1:00.0000}\u2032{3} {4:000;000}\u00b0{5:!00.0000}\u2032{7}",
- dPattern : "{0:00.000000;00.000000}\u00b0{3} {4:000.000000;000.000000}\u00b0{7}",
- sdPattern : "{0:#0.000000}, {4:#0.000000}",
- north : "N",
- south : "S",
- west : "W",
- east : "E"
- },
- ru : true
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/format/nls/ru/coords.js
--- a/src/djol/format/nls/ru/coords.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-define({
- north : "С",
- south : "Ю",
- west : "З",
- east : "В"
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/format/nls/ru/units.js
--- a/src/djol/format/nls/ru/units.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,11 +0,0 @@
-define({
- kmph : "км/ч",
- mps : "м/с",
- knots : "уз",
- meters : "м",
- kilometers : "км",
- meters2 : "м2",
- kilometers2 : "км2",
- nmiles : "миль",
- nmiles2 : "миль2"
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/format/nls/units.js
--- a/src/djol/format/nls/units.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-define({
- root : {
- kmph: "km/h",
- mps: "m/s",
- knots : "kn",
- meters : "m",
- kilometers : "km",
- meters2 : "m2",
- kilometers2 : "m2",
- nmiles : "nmi",
- nmiles2 : "nmi2"
- },
- ru : true
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/interaction/FeatureDrag.js
--- a/src/djol/interaction/FeatureDrag.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,123 +0,0 @@
-define([ "dojo/_base/declare", "ol", "dojo/Evented" ], function(declare, ol,
- Evented) {
-
- var peekFirstFeature = function(map, coordinate, pixel) {
- return map.forEachFeatureAtPixel(function(ft, layer) {
- return ft;
- });
- };
-
- var cls = declare([ ol.interaction.Pointer ], {
- "-chains-" : {
- constructor : "manual"
- },
-
- _peek : null,
-
- _feature : null,
-
- _coordinate : null,
-
- cursor : "pointer",
-
- _oldCursor : undefined,
-
- /**
- * Создает новый объект
- *
- * @param {Object}
- * opts опции
- * @param {Function}
- * opts.peek Функция выбора фичи для перетаскивания
- * function(map,coordinate,pixel), возвращает фичу
- * @param {String}
- * opts.cursor css курсор который будет использован при
- * наведении и перетаскивании фичи
- *
- */
- constructor : function(opts) {
-
- ol.interaction.Pointer.apply(this, [{
- handleDownEvent : this.handleDownEvent,
- handleDragEvent : this.handleDragEvent,
- handleMoveEvent : this.handleMoveEvent,
- handleUpEvent : this.handleUpEvent
- }]);
- Evented.apply(this);
-
- if (opts) {
- if (opts.peek) {
- this._peek = opts.peek;
- } else {
- this._peek = peekFirstFeature;
- }
- if ("cursor" in opts)
- this.cursor = opts.cursor;
- }
- },
-
- handleDownEvent : function(evt) {
- var c = evt.coordinate;
-
- var ft = this._peek(evt.map, c, evt.pixel);
-
- if (ft) {
- this._feature = ft;
- this._coordinate = c;
- this._emit("dragbegin", { feature : ft });
- return true;
- }
-
- return false;
- },
-
- handleDragEvent : function(evt) {
- var c1 = this._coordinate, c2 = evt.coordinate;
-
- var dx = c2[0] - c1[0];
- var dy = c2[1] - c1[1];
-
- this._emit("dragging", { feature : this._feature, fromCoord : c1, toCoord : c2 });
-
- this._feature.getGeometry().translate(dx, dy);
-
- this._coordinate = c2;
- },
-
- handleUpEvent : function(evt) {
- if (this._feature)
- this._emit("dragend", { feature : this._feature });
-
- this._feature = null;
- this._coordinate = null;
- return false;
- },
-
- handleMoveEvent : function(evt) {
- if (this.cursor) {
- var ft = this._feature || this._peek(evt.map, evt.coordinate , evt.pixel);
-
- var element = evt.map.getTargetElement();
- if (ft) {
- if (element.style.cursor != this.cursor) {
- this._oldCursor = element.style.cursor;
- element.style.cursor = this.cursor;
- }
- } else if (this._oldCursor !== undefined) {
- element.style.cursor = this._oldCursor;
- this._oldCursor = undefined;
- }
- }
- },
-
- _emit : function(name, data) {
- var evt = new ol.source.VectorEvent(name,this);
-
- for(var p in data)
- evt[p] = data[p];
- this.dispatchEvent(evt);
- }
- });
-
- return cls;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/listen.js
--- a/src/djol/listen.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-define(["ol"], function(ol) {
-
- var listen = function(target, event, callback) {
- var key = target.on(event, callback);
- return {
- remove : function() {
- ol.Observable.unByKey(key);
- }
- };
- };
-
- listen.once = function(target, event, callback) {
- var key = target.once(event, callback);
- return {
- remove : function() {
- ol.Observable.unByKey(key);
- }
- };
- };
-
- return listen;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/main.js
--- a/src/djol/main.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-define([ "ol" ], function(ol) {
- // вспомогательный класс для получения ol в виде зависимости
- return function() {
- return ol;
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/ol-stub.js
--- a/src/djol/ol-stub.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-var ol;
-define([], function() {
- return ol;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/resources/LayerCheckBoxTemplate.html
--- a/src/djol/resources/LayerCheckBoxTemplate.html Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-
-
-
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/resources/LayerRadioButtonTemplate.html
--- a/src/djol/resources/LayerRadioButtonTemplate.html Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-
-
-
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/resources/LayerSwitcherTemplate.html
--- a/src/djol/resources/LayerSwitcherTemplate.html Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-
-
-
-
-
-
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/resources/PopupContainerTemplate.html
--- a/src/djol/resources/PopupContainerTemplate.html Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-
-
-
-
-
-
-
-
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/djol/resources/mapToolCheckBox.html
--- a/src/djol/resources/mapToolCheckBox.html Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-
-
-
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/Deferred.js
--- a/src/implab/Deferred.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-define(["dojo/Deferred"], function(Deferred) {
- return Deferred;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/Uri.js
--- a/src/implab/Uri.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,232 +0,0 @@
-define(
- [ "./declare" ],
- function(declare) {
- function parseURI(uri) {
- var schema, host, port, path, query, hash, i;
- if (typeof (uri) == "string") {
- if ((i = uri.indexOf(":")) >= 0 &&
- uri.substr(0, i).match(/^\w+$/)) {
- schema = uri.substr(0, i);
- uri = uri.substr(i + 1);
- }
-
- if (uri.indexOf("//") === 0) {
- uri = uri.substr(2);
- if ((i = uri.indexOf("/")) >= 0) {
- host = uri.substr(0, i);
- uri = uri.substr(i);
- } else {
- host = uri;
- uri = "";
- }
- }
-
- if ((i = uri.indexOf("?")) >= 0) {
- path = uri.substr(0, i);
- uri = uri.substr(i + 1);
-
- } else {
- path = uri;
- uri = "";
-
- if ((i = path.indexOf("#")) >= 0) {
- hash = path.substr(i + 1);
- path = path.substr(0, i);
- }
- }
-
- if ((i = uri.indexOf("#")) >= 0) {
- query = uri.substr(0, i);
- hash = uri.substr(i + 1);
- } else {
- query = uri;
- }
- }
-
- if (host && (i = host.lastIndexOf(":")) >= 0) {
- port = host.substr(i + 1);
- host = host.substr(0, i);
- }
-
- return {
- schema : schema,
- host : host,
- port : port,
- path : path,
- query : query,
- hash : hash
- };
- }
-
- function makeURI(options) {
- var uri = [];
-
- if (options.schema)
- uri.push(options.schema, ":");
- if (options.host)
- uri.push("//", options.host);
- if (options.host && options.port)
- uri.push(":", options.port);
-
- if (options.path) {
- if (options.host && options.path[0] != "/")
- uri.push("/");
- uri.push(options.path);
- } else if (options.host) {
- uri.push("/");
- }
-
- if (options.query)
- uri.push("?", options.query);
- if (options.hash)
- uri.push("#", options.hash);
-
- return uri.join("");
- }
-
- function reducePath(parts) {
- var balance = 0, result = [], isRoot;
-
- for (var i = 0; i < parts.length; i++) {
- var part = parts[i];
- switch (part) {
- case "..":
- if (balance > 0) {
- result.pop();
- } else {
- if (isRoot)
- throw new Error("Unbalanced path: " + parts);
-
- result.push(part);
- }
- balance--;
- break;
- case ".":
- break;
- case "":
- if (i === 0) {
- isRoot = true;
- result.push(part);
- }
- break;
- default:
- result.push(part);
- balance++;
- break;
- }
- }
-
- return result.join("/");
- }
-
- var meta = {
- schema : null,
- host : null,
- port : null,
- path : null,
- query : null,
- hash : null
- };
-
- var URI = declare(null, {
- constructor : function(opts) {
- if (typeof (opts) == "string")
- opts = parseURI(opts);
- for ( var p in meta)
- if (p in opts)
- this[p] = opts[p];
- },
-
- clone : function() {
- return new URI(this);
- },
-
- combine : function(rel) {
- var me = this;
-
- if (typeof (rel) === "string")
- rel = new URI(rel);
- else
- rel = rel.clone();
-
- // //some.host:123/path?q=a#123
- if (rel.host)
- return rel;
-
- // /abs/path?q=a#123
- if (rel.path && rel.path[0] == "/") {
- if (me.host) {
- rel.schema = me.schema;
- rel.host = me.host;
- rel.port = me.port;
- }
- return rel;
- }
-
- var base = me.clone();
-
- // rel/path?a=b#cd
- if (rel.path) {
- var segments = base.getSegments();
- segments.pop();
- segments.push.apply(segments, rel.getSegments());
-
- base.path = reducePath(segments);
- }
-
- // ?q=a#123
- if (rel.query)
- base.query = rel.query;
- if (rel.hash)
- base.hase = rel.hash;
-
- return base;
- },
-
- optimize : function() {
- this.path = reducePath(this.getSegments());
- },
-
- getSegments : function() {
- if (typeof (this.path) === "string")
- return this.path.split("/");
- else
- return [];
- },
-
- toString : function() {
- var uri = [], me = this;
-
- if (me.schema)
- uri.push(me.schema, ":");
- if (me.host)
- uri.push("//", me.host);
- if (me.host && me.port)
- uri.push(":", me.port);
-
- if (me.path) {
- if (me.host && me.path[0] != "/")
- uri.push("/");
- uri.push(me.path);
- } else if (me.host) {
- uri.push("/");
- }
-
- if (me.query)
- uri.push("?", me.query);
- if (me.hash)
- uri.push("#", me.hash);
-
- return uri.join("");
- }
-
- });
-
- URI.combine = function(base, rel) {
- if (typeof (base) === "string")
- base = new URI(base);
- return base.combine(rel).toString();
- };
-
- return URI;
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/Uuid.js
--- a/src/implab/Uuid.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,278 +0,0 @@
-// uuid.js
-//
-// Copyright (c) 2010-2012 Robert Kieffer
-// MIT License - http://opensource.org/licenses/mit-license.php
-define([], function () {
- 'use strict';
-
- var _window = 'undefined' !== typeof window ? window : null;
-
- // Unique ID creation requires a high quality random # generator. We
- // feature
- // detect to determine the best RNG source, normalizing to a function
- // that
- // returns 128-bits of randomness, since that's what's usually required
- var _rng, _mathRNG, _nodeRNG, _whatwgRNG, _previousRoot;
-
- function setupBrowser() {
- // Allow for MSIE11 msCrypto
- var _crypto = _window.crypto || _window.msCrypto;
-
- if (!_rng && _crypto && _crypto.getRandomValues) {
- // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
- //
- // Moderately fast, high quality
- try {
- var _rnds8 = new Uint8Array(16);
- _whatwgRNG = _rng = function whatwgRNG() {
- _crypto.getRandomValues(_rnds8);
- return _rnds8;
- };
- _rng();
- } catch (e) { /**/ }
- }
-
- if (!_rng) {
- // Math.random()-based (RNG)
- //
- // If all else fails, use Math.random(). It's fast, but is of
- // unspecified
- // quality.
- var _rnds = new Array(16);
- _mathRNG = _rng = function () {
- for (var i = 0, r; i < 16; i++) {
- if ((i & 0x03) === 0) {
- r = Math.random() * 0x100000000;
- }
- _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
- }
-
- return _rnds;
- };
- if ('undefined' !== typeof console && console.warn) {
- console
- .warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
- }
- }
- }
-
- function setupNode() {
- // Node.js crypto-based RNG -
- // http://nodejs.org/docs/v0.6.2/api/crypto.html
- //
- // Moderately fast, high quality
- if ('function' === typeof require) {
- try {
- var _rb = require('crypto').randomBytes;
- _nodeRNG = _rng = _rb && function () {
- return _rb(16);
- };
- _rng();
- } catch (e) { /**/ }
- }
- }
-
- if (_window) {
- setupBrowser();
- } else {
- setupNode();
- }
-
- // Buffer class to use
- var BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
-
- // Maps for number <-> hex string conversion
- var _byteToHex = [];
- var _hexToByte = {};
- for (var i = 0; i < 256; i++) {
- _byteToHex[i] = (i + 0x100).toString(16).substr(1);
- _hexToByte[_byteToHex[i]] = i;
- }
-
- // **`parse()` - Parse a UUID into it's component bytes**
- function parse(s, buf, offset) {
- var i = (buf && offset) || 0,
- ii = 0;
-
- buf = buf || [];
- s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
- if (ii < 16) { // Don't overflow!
- buf[i + ii++] = _hexToByte[oct];
- }
- });
-
- // Zero out remaining bytes if string was short
- while (ii < 16) {
- buf[i + ii++] = 0;
- }
-
- return buf;
- }
-
- // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
- function unparse(buf, offset) {
- var i = offset || 0,
- bth = _byteToHex;
- return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
- bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] + '-' +
- bth[buf[i++]] + bth[buf[i++]] + '-' + bth[buf[i++]] +
- bth[buf[i++]] + '-' + bth[buf[i++]] + bth[buf[i++]] +
- bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
- }
-
- // **`v1()` - Generate time-based UUID**
- //
- // Inspired by https://github.com/LiosK/UUID.js
- // and http://docs.python.org/library/uuid.html
-
- // random #'s we need to init node and clockseq
- var _seedBytes = _rng();
-
- // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
- // 1)
- var _nodeId = [
- _seedBytes[0] | 0x01,
- _seedBytes[1],
- _seedBytes[2],
- _seedBytes[3],
- _seedBytes[4],
- _seedBytes[5]
- ];
-
- // Per 4.2.2, randomize (14 bit) clockseq
- var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
-
- // Previous uuid creation time
- var _lastMSecs = 0,
- _lastNSecs = 0;
-
- // See https://github.com/broofa/node-uuid for API details
- function v1(options, buf, offset) {
- var i = buf && offset || 0;
- var b = buf || [];
-
- options = options || {};
-
- var clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
-
- // UUID timestamps are 100 nano-second units since the Gregorian
- // epoch,
- // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
- // time is handled internally as 'msecs' (integer milliseconds) and
- // 'nsecs'
- // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
- // 00:00.
- var msecs = (options.msecs != null) ? options.msecs : new Date()
- .getTime();
-
- // Per 4.2.1.2, use count of uuid's generated during the current
- // clock
- // cycle to simulate higher resolution clock
- var nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
-
- // Time since last uuid creation (in msecs)
- var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
-
- // Per 4.2.1.2, Bump clockseq on clock regression
- if (dt < 0 && options.clockseq == null) {
- clockseq = clockseq + 1 & 0x3fff;
- }
-
- // Reset nsecs if clock regresses (new clockseq) or we've moved onto
- // a new
- // time interval
- if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
- nsecs = 0;
- }
-
- // Per 4.2.1.2 Throw error if too many uuids are requested
- if (nsecs >= 10000) {
- throw new Error(
- 'uuid.v1(): Can\'t create more than 10M uuids/sec');
- }
-
- _lastMSecs = msecs;
- _lastNSecs = nsecs;
- _clockseq = clockseq;
-
- // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
- msecs += 12219292800000;
-
- // `time_low`
- var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
- b[i++] = tl >>> 24 & 0xff;
- b[i++] = tl >>> 16 & 0xff;
- b[i++] = tl >>> 8 & 0xff;
- b[i++] = tl & 0xff;
-
- // `time_mid`
- var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
- b[i++] = tmh >>> 8 & 0xff;
- b[i++] = tmh & 0xff;
-
- // `time_high_and_version`
- b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
- b[i++] = tmh >>> 16 & 0xff;
-
- // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
- b[i++] = clockseq >>> 8 | 0x80;
-
- // `clock_seq_low`
- b[i++] = clockseq & 0xff;
-
- // `node`
- var node = options.node || _nodeId;
- for (var n = 0; n < 6; n++) {
- b[i + n] = node[n];
- }
-
- return buf ? buf : unparse(b);
- }
-
- // **`v4()` - Generate random UUID**
-
- // See https://github.com/broofa/node-uuid for API details
- function v4(options, buf, offset) {
- // Deprecated - 'format' argument, as supported in v1.2
- var i = buf && offset || 0;
-
- if (typeof (options) === 'string') {
- buf = (options === 'binary') ? new BufferClass(16) : null;
- options = null;
- }
- options = options || {};
-
- var rnds = options.random || (options.rng || _rng)();
-
- // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
- rnds[6] = (rnds[6] & 0x0f) | 0x40;
- rnds[8] = (rnds[8] & 0x3f) | 0x80;
-
- // Copy bytes to buffer, if provided
- if (buf) {
- for (var ii = 0; ii < 16; ii++) {
- buf[i + ii] = rnds[ii];
- }
- }
-
- return buf || unparse(rnds);
- }
-
- // Export public API
- var uuid = function () {
- return new String(v4());
- };
- uuid.v1 = v1;
- uuid.v4 = v4;
- uuid.create = v4;
- uuid.empty = "00000000-0000-0000-0000-000000000000";
- uuid.parse = parse;
- uuid.unparse = unparse;
- uuid.BufferClass = BufferClass;
- uuid._rng = _rng;
- uuid._mathRNG = _mathRNG;
- uuid._nodeRNG = _nodeRNG;
- uuid._whatwgRNG = _whatwgRNG;
-
- return uuid;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/components/ActivationController.js
--- a/src/implab/components/ActivationController.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,120 +0,0 @@
-define(["dojo/_base/declare", "../guard", "../safe", "../log/_LogMixin"], function (declare, guard, safe, _LogMixin) {
- "use strict";
- return declare([_LogMixin], {
-
- _current: null,
-
- _pending: false,
-
- getCurrent: function () {
- return this._current;
- },
-
- _start: function () {
- if (this._pending)
- throw new Error("The activation/decativation is already pending");
- this._pending = true;
- },
-
- _await: function (d) {
- var me = this;
- return d.then(function (x) {
- me._pending = false;
- return x;
- }, function (e) {
- me._pending = false;
- throw e;
- });
- },
-
- activate: function (component) {
- safe.argumentNotNull(component, "component");
- var me = this;
- if (component.getController() !== this)
- throw new Error("The specified component doesn't belong to this controller");
-
- return me._await(guard(me, "_start").then(function () {
- me._activate(component);
- }));
- },
-
- _activate: function (component) {
- var me = this;
- if (me._current === component)
- return guard(false);
-
- // before activation hook
- return guard(me, "onActivating", [component]).then(function () {
- // deactivate curent
- if (me._current)
- return me._current.deactivate(true).then(function () {
- try {
- me._current.onDeactivated();
- } catch (err) {
- me.error(err);
- }
- // HACK raise deactivated event
- try {
- me.onDeactivated(me._current, component);
- } catch (err) {
- // deactivated shouldn't affect the process
- me.error(err);
- }
- me._current = null;
-
- });
- }).then(function () {
- return component.activate(true);
- }).then(function () {
- me._current = component;
- try {
- me.onActivated(component);
- } catch (err) {
- me.error(err);
- }
-
- });
-
- },
-
- /**
- * Деактивирует текущую компоненту.
- *
- * @async
- * @returns true - компонента была деактивирована, либо нет активной
- * компоненты. false - запрос на деактивацию - отклонен.
- */
- deactivate: function () {
- var me = this;
- return me._await(guard(me, "_start").then(function () {
- return me._deactivate();
- }));
- },
-
- _deactivate: function () {
- var me = this;
- if (!me._current)
- return guard(false);
-
- return guard(me, "onDeactivating").then(function () {
- return me._current.deactivate(true);
- }).then(function () {
- // HACK raise deactivated event
- try {
- me.onDeactivated(me._current);
- } catch (err) {
- me.error(err);
- }
- me._current = null;
- });
- },
-
- onActivating: function (component) {},
-
- onDeactivating: function (component) {},
-
- onDeactivated: function (component, next) {},
-
- onActivated: function (component) {}
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/components/StateMachine.js
--- a/src/implab/components/StateMachine.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-define([ "dojo/_base/declare", "../safe", "../text/format" ], function(declare, safe, format) {
- return declare(null, {
- states : null,
-
- current : null,
-
- constructor : function(opts) {
- safe.argumentNotNull(opts, "opts");
- safe.argumentNotNull(opts.states, "opts.states");
- safe.argumentNotNull(opts.initial, "opts.initial");
-
- this.states = opts.states;
- this.current = opts.initial;
-
- if (safe.isNull(this.states[this.current]))
- throw new Error("Invalid initial state " + this.current);
- },
-
- move : function(input, noThrow) {
- safe.argumentNotNull(input, "input");
-
- var next = this.states[this.current][input];
- if(safe.isNull(next)) {
- if (noThrow)
- return false;
- else
- throw new Error(format("Invalid transition {0}-{1}->?", this.current, input));
- } else {
- this.current = next;
- return true;
- }
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/components/_ActivatableMixin.js
--- a/src/implab/components/_ActivatableMixin.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,153 +0,0 @@
-define(["dojo/_base/declare", "../guard", "./StateMachine", "../log/_LogMixin", ], function (declare, guard, StateMachine, _LogMixin) {
-
- var states = {
- inactive: {
- activate: "activating"
- },
- activating: {
- success: "active",
- failed: "inactive"
- },
- active: {
- deactivate: "deactivating"
- },
- deactivating: {
- success: "inactive",
- failed: "active"
- }
- };
-
- return declare([_LogMixin], {
- _controller: null,
-
- _active: null,
-
- constructor: function () {
- this._active = new StateMachine({
- states: states,
- initial: "inactive"
- });
- },
-
- /**
- * @returns {Object} контроллер для активации текущей компоненты
- */
- getController: function () {
- return this._controller;
- },
-
- /**
- * @param {Object}
- * v Контроллер для активации текущей компоненты
- */
- setController: function (v) {
- this._controller = v;
- },
-
- /**
- * @returns {Boolean} текущая компонента активна
- */
- isActive: function () {
- return this._active.current == "active";
- },
-
- assertActive: function () {
- if (!this.isActive())
- throw new Error("The object must be active to perform the operation");
- },
-
- /**
- * Активирует текущую компоненту, если у текущей компоненты задан
- * контроллер, то активация будет осуществляться через него
- *
- * @async
- * @param{Boolean}
- * direct вызов должен осуществится напрямую, без участия
- * контроллера.
- * @return{Boolean} успешно/неуспешно
- */
- activate: function (direct) {
- var me = this;
- if (!direct && this._controller)
- return me._controller.activate(me).then(function () {
- me.onActivated();
- });
-
- me._active.move("activate");
- return guard(me, "onActivating").then(function () {
- me.log("Activated");
- me._active.move("success");
- if (!me._controller)
- me.onActivated();
- }, function (err) {
- console.error(err);
- me.error("Activation failed: {0}", err);
- me._active.move("failed");
- throw err;
- });
- },
-
- /**
- * Деактивирует текущую компоненту, если у компоненты задан контроллер,
- * то деактивация будет осуществляться через него.
- *
- * @async
- * @param{Boolean} direct вызов должен осуществится напрямую, без
- * участия контроллера.
- *
- */
- deactivate: function (direct) {
- var me = this;
- if (!direct && me._controller)
- return me._controller.deactivate(me).then(function () {
- me.onDeactivated();
- });
-
- me._active.move("deactivate");
- return guard(me, "onDeactivating").then(function () {
- me.log("Deactivated");
- me._active.move("success");
- if (!me._controller)
- me.onDeactivated();
- }, function (err) {
- console.error(err);
- me.error("Deactivation failed: {0}", err);
- me.move("failed");
- throw err;
- });
-
- },
-
- toogleActive: function () {
- var me = this;
- return (me.isActive() ? me.deactivate() : me.activate()).then(function () {
- return me.isActive();
- });
- },
-
- /**
- * Событие вызывается перед активацией текущей компоненты
- *
- * @returns{Boolean|undefined} если false - активация будет отменена
- */
- onActivating: function () {},
-
- /**
- * Событие вызывается перед деактивацией текущей компоненты
- *
- * @returns {Boolean|undefined} если false - деактивация будет отменена
- */
- onDeactivating: function () {},
-
- /**
- * Событие вызывается после активации текущей компоненты
- */
- onActivated: function () {},
-
- /**
- * Событие вызывается после деактивации текущей компоненты
- */
- onDeactivated: function () {}
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/DataContext.js
--- a/src/implab/data/DataContext.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-define([ "dojo/_base/declare", "../safe" ], function(declare, safe) {
- return declare(
- null,
- {
- _params : null,
-
- _repositories : null,
-
- constructor : function(opts) {
- this._params = opts || {};
- this._repositories = {};
- },
-
- getRepository : function(name) {
- safe.argumentNotEmptyString(name, "name");
- var repo = this._repositories[name];
- if (!repo) {
- repo = this._params[name];
- if (!repo)
- throw new Error("The repository '" + name +
- "' isn't found");
- if (repo instanceof Function)
- repo = new repo(); // factory method or constructor
- if (repo.initialize) {
- repo.initialize({
- dataContext : this
- });
- } else if (repo.setDataContext) {
- repo.setDataContext(this);
- }
- this._repositories[name] = repo;
- }
-
- return repo;
- },
-
- dispose : function() {
- for( var name in this._repositories) {
- var r = this._repositories[name];
- if (r.dispose)
- r.dispose();
- }
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/MapSchema.js
--- a/src/implab/data/MapSchema.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-define([ "dojo/_base/declare", "../safe" ], function(declare, safe) {
- return declare(null, {
- /**
- * Отображение одного типа объектов в другой.
- *
- * @remarks Отображения являются односторонними, т.е. позволяют
- * перенести часть содержимого одного объекта в другой. Каждая
- * схема отображения строится из набора примитивных
- * отображений, которые будут применены в произвольном порядке.
- */
- _schema : null,
-
- constructor : function(schema) {
- this._schema = schema;
- },
-
- /**
- * Осуществляет отображение одного объекта в другой
- *
- * @src{Object} Исходный объект из которого будут взяты данные
- * @dst{Object}
- */
- map : function(src, dst, ctx) {
- safe.argumentNotNull(src, "src");
- safe.argumentNotNull(dst, "dst");
-
- for ( var p in this._schema) {
- var mapper = this._schema[p];
- if (mapper instanceof Function) {
- dst[p] = mapper(src[p]);
- } else if (mapper && mapper.map) {
- mapper.map(src, dst, p, ctx);
- } else {
- this._defaultMapper(src, dst, p, mapper, ctx);
- }
- }
- },
-
- _defaultMapper : function(src, dst, prop, opts) {
- if (typeof (opts) == "string") {
- if (opts in src)
- dst[prop] = src[opts];
- } else if (opts && opts.type instanceof Function) {
- if (src[prop] instanceof opts.type)
- dst[prop] = src[prop];
- else
- dst[prop] = this._isPrimitiveType(opts.type) ? opts.type
- .call(null, src[prop]) : new opts.type(src[prop]);
-
- } else {
- if (!(prop in src))
- if (opts && opts.required)
- throw new Error("The " + prop + "is missing");
- else
- return;
- dst[prop] = src[prop];
- }
- },
-
- _isPrimitiveType : function(type) {
- return (type === String || type === Number || type === Boolean
- || type === Number || type === Date);
- }
-
- });
-
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/ObjectStore.js
--- a/src/implab/data/ObjectStore.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,174 +0,0 @@
-define([ "dojo/_base/declare", "dojo/_base/lang", "dojo/_base/array",
- "../safe", "dojo/when", "dojo/Deferred", "dojo/store/util/QueryResults" ], function(declare,
- lang, array, safe, when, Deferred, QueryResults) {
- /**
- * @module implab/data/RestStore
- *
- * Реализует шаблон репозитария dojo/store над уже имеющимся хранилищем. При получении и
- * отправке данных в нижележащие хранилище используется implab/data/MapSchema для преобразования
- * данных.
- */
- return declare(null, {
-
- model: null,
-
- mapping: null,
-
- _dataContext: null,
-
- _store : null, // backing store
-
- _cache : null,
-
- constructor : function(options) {
- options = options || {};
-
- if (options.store)
- this._store = options.store;
-
- if (options.dataContext) {
- this._dataContext = options.dataContext;
- }
-
- if (options.cache === false) {
- // no cache at all
- } else if (options.cache === "string" && options.dataContext) {
- this._cache = this._dataContext.getCache(options.cache);
- } else {
- this._cache = {};
- }
- },
-
- getDataContext : function() {
- return this._dataContext;
- },
-
- // READ
- get : function(id) {
- var me = this;
- var cache = me.getCacheEntry(id);
- if (cache)
- return cache;
- else
- return when(me._store.get(id), function(data) {
- return me._mapToObject(id, data);
- });
- },
-
- query : function(query, options) {
- var me = this;
- var d = me._store.query(query, options);
- var result = QueryResults(when(d, function(data) {
- return array.map(data, function(item) {
- return me._mapToObject(me._store.getIdentity(item), item);
- });
- }));
- result.total = d.total;
- return result;
- },
-
- getIdentity : function(object) {
- return object.getId();
- },
-
- // UPDATE
- put : function(object, directives) {
- return this._store.put(this._mapFromObject(object), directives);
- },
-
- // INSERT
- add : function(object, directives) {
- var me = this;
- // добавляем в хранилище данные, сохраняем в кеше объект с
- // полученным идентификатором
- return when(
- me._store.add(this._mapFromObject(object), directives),
- function(id) {
- object.attach(id, me);
- me.storeCacheEntry(id, object);
- return id;
- });
- },
-
- // DELETE
- remove : function(id) {
- var me = this;
- return when(me._store.remove(id), function() {
- me.removeCacheEntry(id);
- });
- },
-
- _mapToObject : function(id, data) {
- var instance = this.createInstance(id);
- this.populateInstance(instance, data);
- return instance;
- },
-
- _mapFromObject : function(object) {
- return this.serializeInstance(object);
- },
-
- getCacheEntry : function(id) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
-
- return this._cache[id];
- },
-
- storeCacheEntry : function(id, object) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
-
- this._cache[id] = object;
- },
-
- removeCacheEntry : function(id) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
- delete this._cache[id];
- },
-
- /** Создает экземпляр сущности с указанным идентификатором, либо извлекает из кеша, если таковая уже имеется.
- * @remarks
- * Технически сюда можно было бы дополнительно передать данные для ининциализации объекта,
- * но концептуально это не верно, поскольку процесс чтения объекта состоит из двух этапов:
- * 1. Создание пустого объекта (createInstance)
- * 2. Заполнение объекта при помощи схемы отображения (populateInstance)
- * при этом первый этап может быть выполнен за долго до второго, например,
- * при создании заглушек в процессе установления ссылок между объектами.
- */
- createInstance : function(id) {
- var instance = this.getCacheEntry(id);
- if (!instance) {
- instance = this.createInstanceImpl(id);
- this.storeCacheEntry(id, instance);
- }
- return instance;
- },
-
- /** Непосредственно создает экземпляр сущнсти, т.е. является фабричным методом.
- * @param {String} id идентификатор создаваемого экземпляра.
- */
- createInstanceImpl : function(id) {
- var opts = {
- dataContext : this.getDataContext(),
- id : id
- };
-
- return new this.itemsType(opts);
- },
-
- populateInstance : function(instance, data) {
- this.mapping.readData(instance, data,this.getDataContext());
- if (instance.onPopulate)
- instance.onPopulate();
- },
-
- serializeInstance : function(instance) {
- var data = {};
- this.mapping.writeData(instance, data, this.getDataContext());
- return data;
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/RestStore.js
--- a/src/implab/data/RestStore.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,166 +0,0 @@
-define([ "dojo/_base/declare", "dojo/_base/lang", "dojo/_base/array",
- "../safe", "dojo/when", "dojo/Deferred", "dojo/store/util/QueryResults" ], function(declare,
- lang, array, safe, when, Deferred, QueryResults) {
- /**
- * @module implab/data/RestStore
- *
- * Реализует шаблон репозитария dojo/store над уже имеющимся хранилищем. При получении и
- * отправке данных в нижележащие хранилище используется implab/data/MapSchema для преобразования
- * данных.
- */
- return declare(null, {
-
- itemsType : null,
-
- _dataContext : null,
-
- _store : null, // backing store
- _cache : null,
-
- constructor : function(options) {
- options = options || {};
-
- this._cache = {};
- if (options.store)
- this._store = options.store;
- if (options.dataContext)
- this._dataContext = options.dataContext;
- },
-
- setDataContext : function(v) {
- this._dataContext = v;
- },
-
- getDataContext : function() {
- return this._dataContext;
- },
-
- // READ
- get : function(id) {
- var me = this;
- var cache = me.getCacheEntry(id);
- if (cache)
- return cache;
- else
- return when(me._store.get(id), function(data) {
- return me._mapToObject(id, data);
- });
- },
-
- query : function(query, options) {
- var me = this;
- var d = me._store.query(query, options);
- var result = QueryResults(when(d, function(data) {
- return array.map(data, function(item) {
- return me._mapToObject(me._store.getIdentity(item), item);
- });
- }));
- result.total = d.total;
- return result;
- },
-
- getIdentity : function(object) {
- return object.getId();
- },
-
- // UPDATE
- put : function(object, directives) {
- return this._store.put(this._mapFromObject(object), directives);
- },
-
- // INSERT
- add : function(object, directives) {
- var me = this;
- // добавляем в хранилище данные, сохраняем в кеше объект с
- // полученным идентификатором
- return when(
- me._store.add(this._mapFromObject(object), directives),
- function(id) {
- object.attach(id, me);
- me.storeCacheEntry(id, object);
- return id;
- });
- },
-
- // DELETE
- remove : function(id) {
- var me = this;
- return when(me._store.remove(id), function() {
- me.removeCacheEntry(id);
- });
- },
-
- _mapToObject : function(id, data) {
- var instance = this.createInstance(id);
- this.populateInstance(instance, data);
- return instance;
- },
-
- _mapFromObject : function(object) {
- return this.serializeInstance(object);
- },
-
- getCacheEntry : function(id) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
-
- return this._cache[id];
- },
-
- storeCacheEntry : function(id, object) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
-
- this._cache[id] = object;
- },
-
- removeCacheEntry : function(id) {
- safe.argumentNotNull(id, "id");
- id = id.toString();
- delete this._cache[id];
- },
-
- /** Создает экземпляр сущности с указанным идентификатором, либо извлекает из кеша, если таковая уже имеется.
- * @remarks
- * Технически сюда можно было бы дополнительно передать данные для ининциализации объекта,
- * но концептуально это не верно, поскольку процесс чтения объекта состоит из двух этапов:
- * 1. Создание пустого объекта (createInstance)
- * 2. Заполнение объекта при помощи схемы отображения (populateInstance)
- * при этом первый этап может быть выполнен за долго до второго, например,
- * при создании заглушек в процессе установления ссылок между объектами.
- */
- createInstance : function(id) {
- var instance = this.getCacheEntry(id);
- if (!instance) {
- instance = this.createInstanceImpl(id);
- this.storeCacheEntry(id, instance);
- }
- return instance;
- },
-
- /** Непосредственно создает экземпляр сущнсти, т.е. является фабричным методом.
- * @param {String} id идентификатор создаваемого экземпляра.
- */
- createInstanceImpl : function(id) {
- var opts = {
- dataContext : this.getDataContext(),
- id : id
- };
-
- return new this.itemsType(opts);
- },
-
- populateInstance : function(instance, data) {
- this.itemsType.readData(instance, data,this.getDataContext());
- if (instance.onPopulate)
- instance.onPopulate();
- },
-
- serializeInstance : function(instance) {
- var data = {};
- this.itemsType.writeData(instance, data, this.getDataContext());
- return data;
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/StatefullStoreAdapter.js
--- a/src/implab/data/StatefullStoreAdapter.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-define(["dojo/_base/declare", "dojo/_base/array", "../safe", "./StoreAdapter"], function(declare, array, safe ,AdapterStore){
- return declare([AdapterStore], {
- _attrs : null,
-
- constructor : function(opts) {
- safe.argumentNotEmptyArray(opts.attrs, "opts.attrs");
- this._attrs = opts.attrs;
- },
-
- mapItem : function(item) {
- var result = {};
- array.forEach(this._attrs, function(p) {
- result[p] = item.get(p);
- });
- return result;
- }
- });
-
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/StoreAdapter.js
--- a/src/implab/data/StoreAdapter.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,110 +0,0 @@
-define([
- "dojo/_base/declare",
- "../safe",
- "dojo/when",
- "dojo/store/util/QueryResults" ],
-
-function(declare, safe, when, QueryResults) {
-
- "use strict";
-
- /**
- * Обертка вокруг произвольного хранилища, только для чтения. Используется
- * для преобразования данных, например, отображения в списках элементов
- * пространственных данных.
- */
- return declare(null, {
- /**
- * @type{String} Свойство, хранящее идентификатор
- */
- idProperty : null,
-
- _store : null,
-
- /**
- * @param{String} opts.idProperty Имя свойства, в которое будет записан
- * идентификатор, если не указан, то идентификатор будет
- * взят из родительского хранилища или использоваться
- * строка id
- * @param{dojo.store} opts.store Родительское хранилище
- */
- constructor : function(opts) {
- safe.argumentNotNull(opts, "opts");
- safe.argumentNotNull(opts.store, "opts.store");
-
- this._store = opts.store;
- delete opts.store;
- declare.safeMixin(this, opts);
- this.idProperty = opts.idProperty || this._store.idProperty || "id";
- },
-
- getParentStore : function() {
- return this._store;
- },
-
- get : function(id) {
- var me = this;
- return when(me._store.get(id), function(x) {
- var m = me.mapItem(x);
- if (!(me.idProperty in m))
- m[me.idProperty] = id;
- return m;
- });
- },
-
- /**
- * Выполняет запрос в родительском хранилище, для этого используется
- * translateQuery для подготовки запроса, затем,
- * mapItem для преобразования результатов.
- */
- query : function(q, options) {
- var me = this, store = this._store;
- return when(store.query(me.translateQuery(q), me
- .translateOptions(options)), function(res) {
- var total = res.total;
- var mapped = res.map(function(x) {
- var m = me.mapItem(x);
- if (!(me.idProperty in m))
- m[me.idProperty] = store.getIdentity &&
- store.getIdentity(x);
- return m;
- });
- mapped.total = total;
- var results = new QueryResults(mapped);
- console.log(results);
- return results;
- });
- },
-
- getIdentity : function(obj) {
- return obj && obj[this.idProperty];
- },
-
- /**
- * Преобразование запроса в формат родительского хранилища.
- *
- * @param{Object} q Запрос в формате текущего хранилища
- * @returns{Object} Запрос в формате родительского хранилища
- */
- translateQuery : function(q) {
- return q;
- },
-
- translateOptions : function(options) {
- return options;
- },
-
- /**
- * Преобразование объекта из родительского хранилища. При преобразовании
- * в объекте можно задать идентификатор, иначе идентификатор будет
- * автоматически получен и присвоен из родительского хранилища
- *
- * @param{Object} item Объект из родительского хранилища
- * @returns{Object} результат преобразования
- */
- mapItem : function(item) {
- return item;
- }
- });
-
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/_ModelBase.js
--- a/src/implab/data/_ModelBase.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-define(["dojo/_base/declare"], function(declare) {
-
- return declare(null, {
- dataContext : null,
- idField : "id",
- loaded : false,
-
- constructor : function(opts){
- if (opts) {
- if(opts.dataContext)
- this.dataContext = opts.dataContext;
- if(opts.id)
- this[this.idField] = opts.id;
- }
- },
-
- getId : function() {
- return this[this.idField];
- },
-
- attach : function(id, dc) {
- if (this.dataContext)
- throw new Error("The object is already attached");
- this[this.idField] = id;
- this.dataContext = dc;
- },
-
- isAttached : function() {
- return this.dataContext ? true : false;
- },
-
- onPopulate : function() {
- this.loaded = true;
- }
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/_StatefulModelMixin.js
--- a/src/implab/data/_StatefulModelMixin.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-define(["dojo/_base/declare", "dojo/Stateful"], function(declare, Stateful) {
- return declare([Stateful], {
-
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/data/declare-model.js
--- a/src/implab/data/declare-model.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-define([ "dojo/_base/declare", "./_ModelBase", "./MapSchema" ], function(
- declare, _ModelBase, MapSchema) {
- /**
- * Создает новый класс, унаследованный от ./ModelBase, с указанной схемой
- * отображения данных.
- *
- * @details Модель представляет собой объект, живущий в рамках контекста
- * данных, также имеющий две схемы отображения: из модели хранения
- * в источнике данных (toObjectMap) и наооборот в модель хранения в
- * источнике данных (fromObjectMap).
- *
- * Описание схемы выглядит следующим образом
- *
- * {
- * name : null, // отображение в обе стороны без преобразования
- *
- * age : Number, // при преобразоваении к объекту поле будет преобразовано dst.age = Number(src.age)
- * // обратное преобразование отсутстсвует
- *
- * age : [Number, null] // тоже самое что и age : Number
- *
- * date : [Date, function(v) { return v.toString() }] // указывается преобразование в одну и в другую сторону
- * }
- *
- */
- return function(schema, mixins, opts) {
- var fromObjectSchema = {}, toObjectSchema = {};
- if (schema !== null && schema !== undefined) {
- for ( var p in schema) {
- var mapper = schema[p];
-
- if (mapper instanceof Array) {
- toObjectSchema[p] = mapper[0];
- fromObjectSchema[p] = mapper[1];
- } else {
- toObjectSchema[p] = mapper;
- fromObjectSchema[p] = null;
- }
- }
- }
-
- if (arguments.length < 3) {
- opts = mixins;
- mixins = undefined;
- }
-
- var base = [ _ModelBase ];
- if (mixins) {
- if (mixins instanceof Array)
- base = base.concat(mixins);
- else
- base.push(mixins);
- }
-
- var model = declare(base, opts);
-
- model.toObjectMap = new MapSchema(toObjectSchema);
-
- model.fromObjectMap = new MapSchema(fromObjectSchema);
-
- model.readData = function(that, data, context) {
- model.toObjectMap.map(data, that, context);
- };
-
- model.writeData = function(that, data, context) {
- data = data || {};
- model.fromObjectMap.map(that, data, context);
- };
-
- return model;
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/declare.js
--- a/src/implab/declare.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-define([
- './declare/_load!'
-], function(declare) {
- 'use strict';
- return declare;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/declare/_load.js
--- a/src/implab/declare/_load.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-define([], function () {
- 'use strict';
-
- return {
- load: function (id, require, callback) {
- require(['dojo/_base/declare'], function (declare) {
- callback(declare);
- });
- }
- };
-
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/declare/override.js
--- a/src/implab/declare/override.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,73 +0,0 @@
-"use strict";
-define([], function () {
- var slice = Array.prototype.slice;
- var override = function (method) {
- var proxy;
-
- /** @this target object */
- proxy = function () {
- var me = this;
- var inherited = (this.getInherited && this.getInherited(proxy.nom, {
- callee: proxy
- })) || function () {};
-
- return method.apply(me, [function () {
- return inherited.apply(me, arguments);
- }].concat(slice.apply(arguments)));
- };
-
- proxy.method = method;
- proxy.overrides = true;
-
- return proxy;
- };
-
- override.before = function (method) {
- var proxy;
-
- /** @this target object */
- proxy = function () {
- var me = this;
- var inherited = (this.getInherited && this.getInherited(proxy.nom, {
- callee: proxy
- })) || function () {};
-
-
- method.apply(me, arguments);
- return inherited.apply(me, arguments);
- };
-
- proxy.method = method;
- proxy.overrides = true;
-
- return proxy;
- };
-
- override.after = function (method) {
- var proxy;
-
- /** @this target object */
- proxy = function () {
- var me = this;
- var inherited = (this.getInherited && this.getInherited(proxy.nom, {
- callee: proxy
- })) || function () {};
-
- inherited.apply(me, arguments);
-
- return method.apply(me, arguments);
- };
-
- proxy.method = method;
- proxy.overrides = true;
-
- return proxy;
- };
-
- override.hide = function (method) {
- method.overrides = false;
- return method;
- };
-
- return override;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/ActivationContext.js
--- a/src/implab/di/ActivationContext.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,138 +0,0 @@
-define([
- "../declare",
- "../safe",
- "./Descriptor",
- "./ValueDescriptor",
- "../log/trace!"
-], function (declare, safe, Descriptor, Value, trace) {
- var Context = declare(null, {
-
- _cache: null,
-
- _services: null,
-
- _stack: null,
-
- _visited: null,
-
- container: null,
-
- _trace: true,
-
- constructor: function (container, services, cache, visited) {
- safe.argumentNotNull(container, "container");
- safe.argumentNotNull(services, "services");
-
- this._visited = visited || {};
- this._stack = [];
- this._cache = cache || {};
- this._services = services;
- this.container = container;
- },
-
- getService: function (name, def) {
- var d = this._services[name];
-
- if (!d)
- if (arguments.length > 1)
- return def;
- else
- throw new Error("Service '" + name + "' not found");
-
- return d.activate(this, name);
- },
-
- /**
- * registers services local to the the activation context
- *
- * @name{string} the name of the service
- * @service{string} the service descriptor to register
- */
- register: function (name, service) {
- safe.argumentNotEmptyString(name, "name");
-
- if (!(service instanceof Descriptor))
- service = new Value(service, true);
- this._services[name] = service;
- },
-
- clone: function () {
- return new Context(
- this.container,
- Object.create(this._services),
- this._cache,
- this._visited
- );
-
- },
-
- has: function (id) {
- return id in this._cache;
- },
-
- get: function (id) {
- return this._cache[id];
- },
-
- store: function (id, value) {
- return (this._cache[id] = value);
- },
-
- parse: function (data, name) {
- var me = this;
- if (safe.isPrimitive(data))
- return data;
-
- if (data instanceof Descriptor) {
- return data.activate(this, name);
- } else if (data instanceof Array) {
- me.enter(name);
- var v = data.map(function (x, i) {
- return me.parse(x, "." + i);
- });
- me.leave();
- return v;
- } else {
- me.enter(name);
- var result = {};
- for (var p in data)
- result[p] = me.parse(data[p], "." + p);
- me.leave();
- return result;
- }
- },
-
- visit: function (id) {
- var count = this._visited[id] || 0;
- this._visited[id] = count + 1;
- return count;
- },
-
- getStack: function () {
- return this._stack.slice().reverse();
- },
-
- enter: function (name, d, localize) {
- if (this._trace)
- trace.log("enter " + name + " " + (d || "") +
- (localize ? " localize" : ""));
- this._stack.push({
- name: name,
- service: d,
- scope: this._services
- });
- if (localize)
- this._services = Object.create(this._services);
- },
-
- leave: function () {
- var ctx = this._stack.pop();
- this._services = ctx.scope;
-
- if (this._trace)
- trace.log("leave " + ctx.name + " " + (ctx.service || ""));
- }
- });
-
- return Context;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/ActivationError.js
--- a/src/implab/di/ActivationError.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,39 +0,0 @@
-define([
- "../declare"
-], function (declare) {
- return declare(null, {
- activationStack: null,
-
- service: null,
-
- innerException: null,
-
- message: null,
-
- constructor: function (service, activationStack, innerException) {
- this.message = "Failed to activate the service";
- this.activationStack = activationStack;
- this.service = service;
- this.innerException = innerException;
- },
-
- toString: function () {
- var parts = [this.message];
- if (this.service)
- parts.push("when activating: " + this.service.toString());
-
- if (this.innerException)
- parts.push("caused by: " + this.innerException.toString());
-
- if (this.activationStack) {
- parts.push("at");
- this.activationStack.forEach(function (x) {
- parts.push(" " + x.name + " " +
- (x.service ? x.service.toString() : ""));
- });
- }
-
- return parts.join("\n");
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/Container.js
--- a/src/implab/di/Container.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,299 +0,0 @@
-define([
- "../declare",
- "../safe",
- "../Uuid",
- "../Deferred",
- "./ActivationContext",
- "./Descriptor",
- "./ValueDescriptor",
- "./ReferenceDescriptor",
- "./ServiceDescriptor",
- "./ActivationError"
-], function (
- declare,
- safe,
- Uuid,
- Deferred,
- ActivationContext,
- Descriptor,
- Value,
- Reference,
- Service,
- ActivationError) {
- var Container = declare(null, {
- _services: null,
- _cache: null,
- _cleanup: null,
- _root: null,
- _parent: null,
-
- constructor: function (parent) {
- this._parent = parent;
- this._services = parent ? Object.create(parent._services) : {};
- this._cache = {};
- this._cleanup = [];
- this._root = parent ? parent.getRootContainer() : this;
- this._services.container = new Value(this, true);
- },
-
- getRootContainer: function () {
- return this._root;
- },
-
- getParent: function () {
- return this._parent;
- },
-
- /**
- *
- */
- getService: function (name, def) {
- var d = this._services[name];
- if (!d)
- if (arguments.length > 1)
- return def;
- else
- throw new Error("Service '" + name + "' isn't found");
- if (d.isInstanceCreated())
- return d.getInstance();
-
- var context = new ActivationContext(this, this._services);
-
- try {
- return d.activate(context, name);
- } catch (error) {
- throw new ActivationError(name, context.getStack(), error);
- }
- },
-
- register: function (name, service) {
- if (arguments.length == 1) {
- var data = name;
- for (name in data)
- this.register(name, data[name]);
- } else {
- if (!(service instanceof Descriptor))
- service = new Value(service, true);
- this._services[name] = service;
- }
- return this;
- },
-
- onDispose: function (callback) {
- if (!(callback instanceof Function))
- throw new Error("The callback must be a function");
- this._cleanup.push(callback);
- },
-
- dispose: function () {
- if (this._cleanup) {
- for (var i = 0; i < this._cleanup.length; i++)
- this._cleanup[i].call(null);
- this._cleanup = null;
- }
- },
-
- /**
- * @param{String|Object} config
- * The configuration of the contaier. Can be either a string or an object,
- * if the configuration is an object it's treated as a collection of
- * services which will be registed in the contaier.
- *
- * @param{Function} opts.contextRequire
- * The function which will be used to load a configuration or types for services.
- *
- */
- configure: function (config, opts) {
- var p, me = this,
- contextRequire = (opts && opts.contextRequire);
-
- if (typeof (config) === "string") {
- p = new Deferred();
- if (!contextRequire) {
- var shim = [config, new Uuid()].join(config.indexOf("/") != -1 ? "-" : "/");
- define(shim, ["require", config], function (ctx, data) {
- p.resolve([data, {
- contextRequire: ctx
- }]);
- });
- require([shim]);
- } else {
- // TODO how to get correct contextRequire for the relative config module?
- contextRequire([config], function (data) {
- p.resolve([data, {
- contextRequire: contextRequire
- }]);
- });
- }
-
- return p.then(function (args) {
- return me._configure.apply(me, args);
- });
- } else {
- return me._configure(config, opts);
- }
- },
-
- createChildContainer: function () {
- return new Container(this);
- },
-
- has: function (id) {
- return id in this._cache;
- },
-
- get: function (id) {
- return this._cache[id];
- },
-
- store: function (id, value) {
- return (this._cache[id] = value);
- },
-
- _configure: function (data, opts) {
- var typemap = {},
- d = new Deferred(),
- me = this,
- p,
- contextRequire = (opts && opts.contextRequire) || require;
-
- var services = {};
-
- for (p in data) {
- var service = me._parse(data[p], typemap);
- if (!(service instanceof Descriptor))
- service = new Value(service, false);
- services[p] = service;
- }
-
- me.register(services);
-
- var names = [];
-
- for (p in typemap)
- names.push(p);
-
- if (names.length) {
- contextRequire(names, function () {
- for (var i = 0; i < names.length; i++)
- typemap[names[i]] = arguments[i];
- d.resolve(me);
- });
- } else {
- d.resolve(me);
- }
- return d.promise;
- },
-
- _parse: function (data, typemap) {
- if (safe.isPrimitive(data) || data instanceof Descriptor)
- return data;
- if (data.$dependency)
- return new Reference(
- data.$dependency,
- data.lazy,
- data.optional,
- data["default"],
- data.services && this._parseObject(data.services, typemap));
- if (data.$value) {
- var raw = !data.parse;
- return new Value(raw ? data.$value : this._parse(
- data.$value,
- typemap), raw);
- }
- if (data.$type || data.$factory)
- return this._parseService(data, typemap);
- if (data instanceof Array)
- return this._parseArray(data, typemap);
-
- return this._parseObject(data, typemap);
- },
-
- _parseService: function (data, typemap) {
- var me = this,
- opts = {
- owner: this
- };
- if (data.$type) {
-
- opts.type = data.$type;
-
- if (typeof (data.$type) === "string") {
- typemap[data.$type] = null;
- opts.typeMap = typemap;
- }
- }
-
- if (data.$factory)
- opts.factory = data.$factory;
-
- if (data.services)
- opts.services = me._parseObject(data.services, typemap);
- if (data.inject)
- opts.inject = data.inject instanceof Array ? data.inject.map(function (x) {
- return me._parseObject(x, typemap);
- }) : me._parseObject(data.inject, typemap);
- if (data.params)
- opts.params = me._parse(data.params, typemap);
-
- if (data.activation) {
- if (typeof (data.activation) === "string") {
- switch (data.activation.toLowerCase()) {
- case "singleton":
- opts.activation = Service.SINGLETON;
- break;
- case "container":
- opts.activation = Service.CONTAINER;
- break;
- case "hierarchy":
- opts.activation = Service.HIERARCHY;
- break;
- case "context":
- opts.activation = Service.CONTEXT;
- break;
- case "call":
- opts.activation = Service.CALL;
- break;
- default:
- throw new Error("Unknown activation type: " +
- data.activation);
- }
- } else {
- opts.activation = Number(data.activation);
- }
- }
-
- if (data.cleanup)
- opts.cleanup = data.cleanup;
-
- return new Service(opts);
- },
-
- _parseObject: function (data, typemap) {
- if (data.constructor &&
- data.constructor.prototype !== Object.prototype)
- return new Value(data, true);
-
- var o = {};
-
- for (var p in data)
- o[p] = this._parse(data[p], typemap);
-
- return o;
- },
-
- _parseArray: function (data, typemap) {
- if (data.constructor &&
- data.constructor.prototype !== Array.prototype)
- return new Value(data, true);
-
- var me = this;
- return data.map(function (x) {
- return me._parse(x, typemap);
- });
- }
-
- });
-
- return Container;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/Descriptor.js
--- a/src/implab/di/Descriptor.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-define([], function() {
- // abstract base type for descriptros
- return function() {};
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/ReferenceDescriptor.js
--- a/src/implab/di/ReferenceDescriptor.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,90 +0,0 @@
-define([
- "../declare", "../safe", "./Descriptor", "./ActivationError", "./ValueDescriptor"
-],
-
-function(declare, safe, Descriptor, ActivationError, Value) {
- return declare(Descriptor, {
- _name : null,
- _lazy : false,
- _optional : false,
- _default : undefined,
-
- constructor : function(name, lazy, optional, def, services) {
- safe.argumentNotEmptyString(name, "name");
- this._name = name;
- this._lazy = Boolean(lazy);
- this._optional = Boolean(optional);
- this._default = def;
- this._services = services;
- },
-
- activate : function(context, name) {
- var me = this;
-
- context.enter(name, this, true);
-
- // добавляем сервисы
- if (me._services) {
- for ( var p in me._services) {
- var sv = me._services[p];
- context.register(p, sv instanceof Descriptor ? sv : new Value(sv, false));
- }
- }
-
- if (me._lazy) {
- // сохраняем контекст активации
- context = context.clone();
- return function(cfg) {
- // защищаем контекст на случай исключения в процессе
- // активации
- var ct = context.clone();
- try {
- if (cfg)
- safe.each(cfg, function(v, k) {
- ct.register(k, v instanceof Descriptor ? v : new Value(v, false));
- });
- return me._optional ? ct.getService(me._name, me._default) : ct
- .getService(me._name);
- } catch (error) {
- throw new ActivationError(me._name, ct.getStack(), error);
- }
- };
- }
-
- var v = me._optional ? context.getService(me._name, me._default) : context
- .getService(me._name);
- context.leave(me);
- return v;
- },
-
- isInstanceCreated : function() {
- return false;
- },
-
- toString : function() {
- var opts = [];
- if (this._optional)
- opts.push("optional");
- if (this._lazy)
- opts.push("lazy");
-
- var parts = [
- "@ref "
- ];
- if (opts.length) {
- parts.push("{");
- parts.push(opts.join());
- parts.push("} ");
- }
-
- parts.push(this._name);
-
- if (!safe.isNull(this._default)) {
- parts.push(" = ");
- parts.push(this._default);
- }
-
- return parts.join("");
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/ServiceDescriptor.js
--- a/src/implab/di/ServiceDescriptor.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,289 +0,0 @@
-define(
- [
- "../declare",
- "../safe",
- "./Descriptor",
- "./ValueDescriptor"
- ],
-
- function (declare, safe, Descriptor, Value) {
- var SINGLETON_ACTIVATION = 1,
- CONTAINER_ACTIVATION = 2,
- CONTEXT_ACTIVATION = 3,
- CALL_ACTIVATION = 4,
- HIERARCHY_ACTIVATION = 5;
-
- var injectMethod = function (target, method, context, args) {
- var m = target[method];
- if (!m)
- throw new Error("Method '" + method + "' not found");
-
- if (args instanceof Array)
- m.apply(target, context.parse(args, "." + method));
- else
- m.call(target, context.parse(args, "." + method));
- };
-
- var makeClenupCallback = function (target, method) {
- if (typeof (method) === "string") {
- return function () {
- target[method]();
- };
- } else {
- return function () {
- method(target);
- };
- }
- };
-
- var cacheId = 0;
-
- var cls = declare(
- Descriptor, {
- _instance: null,
- _hasInstance: false,
- _activationType: CALL_ACTIVATION,
- _services: null,
- _type: null,
- _typeMap: null,
- _factory: null,
- _params: undefined,
- _inject: null,
- _cleanup: null,
- _cacheId: null,
- _owner: null,
-
- constructor: function (opts) {
- safe.argumentNotNull(opts, "opts");
- safe.argumentNotNull(opts.owner, "opts.owner");
-
- this._owner = opts.owner;
-
- if (!(opts.type || opts.factory))
- throw new Error(
- "Either a type or a factory must be specified");
-
- if (typeof (opts.type) === "string" && !opts.typeMap)
- throw new Error(
- "The typeMap is required when the type is specified by its name");
-
- if (opts.activation)
- this._activationType = opts.activation;
- if (opts.type)
- this._type = opts.type;
- if (opts.params)
- this._params = opts.params;
- if (opts.inject)
- this._inject = opts.inject instanceof Array ? opts.inject : [opts.inject];
- if (opts.services)
- this._services = opts.services;
- if (opts.factory)
- this._factory = opts.factory;
- if (opts.typeMap)
- this._typeMap = opts.typeMap;
- if (opts.cleanup) {
- if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
- throw new Error(
- "The cleanup parameter must be either a function or a function name");
-
- this._cleanup = opts.cleanup;
- }
-
- this._cacheId = ++cacheId;
- },
-
- activate: function (context, name) {
-
- // if we have a local service records, register them first
-
- var instance;
-
- switch (this._activationType) {
- case 1: // SINGLETON
- // if the value is cached return it
- if (this._hasInstance)
- return this._instance;
-
- var tof = this._type || this._factory;
-
- // create the persistent cache identifier for the type
- if (safe.isPrimitive(tof))
- this._cacheId = this._type;
- else
- this._cacheId = safe.oid(tof);
-
- // singletons are bound to the root container
- var container = context.container.getRootContainer();
-
- if (container.has(this._cacheId)) {
- instance = container.get(this._cacheId);
- } else {
- instance = this._create(context, name);
- container.store(this._cacheId, instance);
- if (this._cleanup)
- container.onDispose(
- makeClenupCallback(instance, this._cleanup));
- }
-
- this._hasInstance = true;
- return (this._instance = instance);
-
- case 2: // CONTAINER
- //return a cached value
- if (this._hasInstance)
- return this._instance;
-
- // create an instance
- instance = this._create(context, name);
-
- // the instance is bound to the container
- if (this._cleanup)
- this._owner.onDispose(
- makeClenupCallback(instance, this._cleanup));
-
- // cache and return the instance
- this._hasInstance = true;
- return (this._instance = instance);
- case 3: // CONTEXT
- //return a cached value if one exists
- if (context.has(this._cacheId))
- return context.get(this._cacheId);
- // context context activated instances are controlled by callers
- return context.store(this._cacheId, this._create(
- context,
- name));
- case 4: // CALL
- // per-call created instances are controlled by callers
- return this._create(context, name);
- case 5: // HIERARCHY
- // hierarchy activated instances are behave much like container activated
- // except they are created and bound to the child container
-
- // return a cached value
- if (context.container.has(this._cacheId))
- return context.container.get(this._cacheId);
-
- instance = this._create(context, name);
-
- if (this._cleanup)
- context.container.onDispose(makeClenupCallback(
- instance,
- this._cleanup));
-
- return context.container.store(this._cacheId, instance);
- default:
- throw "Invalid activation type: " + this._activationType;
- }
- },
-
- isInstanceCreated: function () {
- return this._hasInstance;
- },
-
- getInstance: function () {
- return this._instance;
- },
-
- _create: function (context, name) {
- context.enter(name, this, Boolean(this._services));
-
- if (this._activationType != CALL_ACTIVATION &&
- context.visit(this._cacheId) > 0)
- throw new Error("Recursion detected");
-
- if (this._services) {
- for (var p in this._services) {
- var sv = this._services[p];
- context.register(p, sv instanceof Descriptor ? sv : new Value(sv, false));
- }
- }
-
- var instance;
-
- if (!this._factory) {
- var ctor, type = this._type;
-
- if (typeof (type) === "string") {
- ctor = this._typeMap[type];
- if (!ctor)
- throw new Error("Failed to resolve the type '" +
- type + "'");
- } else {
- ctor = type;
- }
-
- if (this._params === undefined) {
- this._factory = function () {
- return new ctor();
- };
- } else if (this._params instanceof Array) {
- this._factory = function () {
- var inst = Object.create(ctor.prototype);
- var ret = ctor.apply(inst, arguments);
- return typeof (ret) === "object" ? ret : inst;
- };
- } else {
- this._factory = function (param) {
- return new ctor(param);
- };
- }
- }
-
- if (this._params === undefined) {
- instance = this._factory();
- } else if (this._params instanceof Array) {
- instance = this._factory.apply(this, context.parse(
- this._params,
- ".params"));
- } else {
- instance = this._factory(context.parse(
- this._params,
- ".params"));
- }
-
- if (this._inject) {
- this._inject.forEach(function (spec) {
- for (var m in spec)
- injectMethod(instance, m, context, spec[m]);
- });
- }
-
- context.leave();
-
- return instance;
- },
-
- // @constructor {singleton} foo/bar/Baz
- // @factory {singleton}
- toString: function () {
- var parts = [];
-
- parts.push(this._type ? "@constructor" : "@factory");
-
- parts.push(activationNames[this._activationType]);
-
- if (typeof (this._type) === "string")
- parts.push(this._type);
-
- return parts.join(" ");
- }
-
- });
-
- cls.SINGLETON = SINGLETON_ACTIVATION;
- cls.CONTAINER = CONTAINER_ACTIVATION;
- cls.CONTEXT = CONTEXT_ACTIVATION;
- cls.CALL = CALL_ACTIVATION;
- cls.HIERARCHY = HIERARCHY_ACTIVATION;
-
- var activationNames = [
- "",
- "{singleton}",
- "{container}",
- "{context}",
- "{call}",
- "{hierarchy}"
- ];
-
- return cls;
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/di/ValueDescriptor.js
--- a/src/implab/di/ValueDescriptor.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-define([ "../declare", "./Descriptor", "../safe" ],
-
-function(declare, Descriptor, safe) {
- return declare(Descriptor, {
- _value : undefined,
- _raw : false,
- constructor : function(value, raw) {
- this._value = value;
- this._raw = Boolean(raw);
- },
-
- activate : function(context, name) {
- context.enter(name, this);
- var v = this._raw ? this._value : context.parse(
- this._value,
- ".params");
- context.leave(this);
- return v;
- },
-
- isInstanceCreated : function() {
- return this._raw;
- },
-
- getInstance : function() {
- if (!this._raw)
- throw new Error("The instance isn't constructed");
- return this._value;
- },
-
- toString : function() {
- if (this._raw)
- return "@value {raw}";
- else
- return safe.isNull(this._value) ? "@value " : "@value";
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/dom/css.js
--- a/src/implab/dom/css.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-define(["./inject"], function (inject) {
- return {
- load: function (id, require, cb) {
- var url = require.toUrl(id);
- inject.injectStylesheet(url).then(function () {
- cb();
- });
- }
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/dom/inject.js
--- a/src/implab/dom/inject.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,86 +0,0 @@
-define(["../Deferred", "../log/trace!"], function (Deferred, trace) {
- function on(node, eventName, handler) {
- // Add an event listener to a DOM node
- node.addEventListener(eventName, handler, false);
-
- return function () {
- node.removeEventListener(eventName, handler, false);
- };
- }
-
- return {
- injectionPoint: document.head,
- injectBefore: document.head.firstChild,
-
- _map: {},
-
- _inject: function (name, attr) {
- var node = document.createElement(name),
- d = new Deferred(),
-
- cleanup = function () {
- noerr();
- noload();
- },
-
- noload = on(node, "load", function () {
- d.resolve({
- node: node
- });
- cleanup();
- }, true),
-
- noerr = on(node, "error", function (e) {
- d.reject({
- erorr: e,
- node: node
- });
- cleanup();
- }, true);
-
- for (var p in attr)
- node[p] = attr[p];
-
- this.injectionPoint.insertBefore(node, this.injectBefore);
- return d;
- },
-
- injectScript: function (url) {
- var d = this._map[url];
- if (!d) {
- trace.log("js {0}", url);
- d = this._inject("script", {
- type: "text/javascript",
- charset: "utf-8",
- src: url
- });
- d.then(function () {
- trace.log("done {0}", url);
- }, function (e) {
- trace.err([url, e]);
- });
- this._map[url] = d;
- }
- return d;
- },
-
- injectStylesheet: function (url) {
- var d = this._map[url];
- if (!d) {
- trace.log("css {0}", url);
- d = this._inject("link", {
- type: "text/css",
- rel: "stylesheet",
- href: url
- });
- d.then(function () {
- trace.log("done {0}", url);
- }, function (e) {
- trace.error([url, e]);
- });
- this._map[url] = d;
- }
- return d;
- }
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/guard.js
--- a/src/implab/guard.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-define([ "./Deferred" ], function(Deferred) {
- var toPromise = function(d) {
- if (d && d.then)
- return d;
- var d2 = new Deferred();
- d2.resolve(d);
- return d2;
- };
-
- /**
- * функция для асинхронного выполнения метода
- *
- * @async
- * @param{Object} o Объект, который будет использован в качестве
- * this, если не указан, будет
- * null
- * @param{Function|String} m Функция или имя метода, обязательный параметр.
- * Если указано имя, тогда параметр o
- * также должен быть задан
- * @param{Array} args Параметры для вызова метода, не обязательно.
- * @returns{dojo/promise}
- * @deprecated use safe.async() + when() instead.
- */
- return function(o, m, args) {
- if (arguments.length == 1) {
- m = o;
- o = null;
- } else if (arguments.length == 2 && o instanceof Function &&
- m instanceof Array) {
- args = m;
- m = o;
- o = null;
- }
-
- try {
- if (!(m instanceof Function)) {
- if (o)
- m = o[m];
- else if (arguments.length == 1)
- return toPromise(m);
- else
- throw new Error("The target object must be specified");
- }
-
- if (!m)
- throw new Error("Method not found");
-
- return toPromise(m.apply(o, args));
- } catch (err) {
- var d = new Deferred();
- d.reject(err);
- return d;
- }
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/log/ConsoleLogChannel.js
--- a/src/implab/log/ConsoleLogChannel.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-define(
- [ "dojo/_base/declare", "../text/format" ],
- function(declare, format) {
- return declare(
- null,
- {
- name : null,
-
- constructor : function(name) {
- this.name = name;
- },
-
- log : function() {
- console.log(this._makeMsg(arguments));
- },
-
- warn : function() {
- console.warn(this._makeMsg(arguments));
- },
-
- error : function() {
- console.error(this._makeMsg(arguments));
- },
-
- _makeMsg : function(args) {
- return this.name ? this.name + " " +
- format.apply(null, args) : format.apply(null, args);
- }
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/log/_LogMixin.js
--- a/src/implab/log/_LogMixin.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-define([ "dojo/_base/declare" ],
-
-function(declare) {
- var cls = declare(null, {
- _logChannel : null,
-
- _logLevel : 1,
-
- constructor : function(opts) {
- if (typeof opts == "object") {
- if ("logChannel" in opts)
- this._logChannel = opts.logChannel;
- if ("logLevel" in opts)
- this._logLevel = opts.logLevel;
- }
- },
-
- getLogChannel : function() {
- return this._logChannel;
- },
-
- setLogChannel : function(v) {
- this._logChannel = v;
- },
-
- getLogLevel : function() {
- return this._logLevel;
- },
-
- setLogLevel : function(v) {
- this._logLevel = v;
- },
-
- log : function(format) {
- if (this._logChannel && this._logLevel > 2)
- this._logChannel.log.apply(this._logChannel, arguments);
- },
- warn : function(format) {
- if (this._logChannel && this._logLevel > 1)
- this._logChannel.warn.apply(this._logChannel, arguments);
- },
- error : function(format) {
- if (this._logChannel && this._logLevel > 0)
- this._logChannel.error.apply(this._logChannel, arguments);
- },
-
- /**
- * Used to by widgets
- */
- startup : function() {
- var me = this, parent;
- if (!me.getLogChannel()) {
- parent = me;
- while (parent = parent.getParent()) {
- if (parent.getLogChannel) {
- me.setLogChannel(parent.getLogChannel());
- if(parent.getLogLevel)
- me.setLogLevel(parent.getLogLevel());
- break;
- }
- }
- }
- this.inherited(arguments);
- }
- });
- return cls;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/log/listeners/console.js
--- a/src/implab/log/listeners/console.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-define([], function () {
- if (console && console.log)
- return function (ch, name, msg) {
-
- var args = [ch + ":"];
-
- switch (name) {
- case "warn":
- case "error":
- case "log":
- break;
- default:
- args.push(name + ":");
- name = "log";
- }
-
-
- if (msg instanceof Array)
- args.push.apply(args, msg);
- else
- args.push(msg);
-
- console[name].apply(console, args);
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/log/trace.js
--- a/src/implab/log/trace.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-define(["../text/format"], function (format) {
- 'use strict';
-
- var listeners = [];
- var channels = {};
-
- var Trace = function (name) {
- this.name = name;
- this._subscribers = [];
- };
-
- Trace.prototype.debug = function () {
- if (Trace.level >= 4)
- this.notify("debug", format.apply(null, arguments));
- };
-
- Trace.prototype.log = function () {
- if (Trace.level >= 3)
- this.notify("log", format.apply(null, arguments));
- };
-
- Trace.prototype.warn = function () {
- if (Trace.level >= 2)
- this.notify("warn", format.apply(null, arguments));
-
- };
-
- Trace.prototype.error = function () {
- if (Trace.level >= 1)
- this.notify("error", format.apply(null, arguments));
- };
-
- Trace.prototype.notify = function (name, msg) {
- var me = this;
- me._subscribers.forEach(function (cb) {
- cb(me, name, msg);
- });
- };
-
- Trace.prototype.subscribe = function (cb) {
- this._subscribers.push(cb);
- };
-
- Trace.prototype.toString = function () {
- return this.name;
- };
-
- Trace.createChannel = function (type, name, cb) {
- var chId = name;
- if (channels[chId])
- return channels[chId];
-
- var channel = new type(chId);
- channels[chId] = channel;
-
- Trace._onNewChannel(chId, channel);
- cb(channel);
- };
-
- Trace._onNewChannel = function (chId, ch) {
- listeners.forEach(function (listener) {
- listener(chId, ch);
- });
- };
-
- Trace.on = function (filter, cb) {
- if (arguments.length == 1) {
- cb = filter;
- filter = undefined;
- }
- var d, test;
- if (filter instanceof RegExp) {
- test = function (chId) {
- return filter.test(chId);
- };
- } else if (filter instanceof Function) {
- test = filter;
- } else if (filter) {
- test = function (chId) {
- return chId == filter;
- };
- }
-
- if (test) {
- d = function(chId, ch) {
- if(test(chId))
- ch.subscribe(cb);
- };
- } else {
- d = function(chId, ch) {
- ch.subscribe(cb);
- };
- }
- listeners.push(d);
-
- for(var chId in channels)
- d(chId,channels[chId]);
- };
-
- Trace.load = function (id, require, cb) {
- if (id)
- Trace.createChannel(Trace, id, cb);
- else if (require.module && require.module.mid)
- Trace.createChannel(Trace, require.module.mid, cb);
- else
- require(['module'], function (module) {
- Trace.createChannel(Trace, module && module.id, cb);
- });
- };
-
- Trace.dynamic = true;
-
- Trace.level = 4;
-
- return Trace;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/messaging/Client.js
--- a/src/implab/messaging/Client.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-define(
- [ "dojo/_base/declare", "dojo/_base/lang", "dojo/Evented", "../log/_LogMixin" ],
-
- function(declare, lang, Evented, _LogMixin) {
- return declare([ Evented, _LogMixin ], {
- _session : null,
- _destination : null,
- _id : null,
-
- constructor : function(session, destination, options) {
- this._destination = destination;
- this._session = session;
- },
-
- getDestination : function() {
- return this._destination;
- },
-
- start : function() {
- var me = this;
- return me._session.createClient(me.prepareOptions({})).then(
- function(id) {
- me._id = id;
- return me;
- });
- },
-
- prepareOptions : function(options) {
- var me = this;
- options.mode = me.getMode();
- options.destination = me.getDestination();
- options.client = function(msg) {
- me.process(msg);
- };
- return options;
- },
-
- process : function(msg) {
- this.warn("Messages are not acceped by this client");
- },
-
- stop : function() {
- var me = this;
- if (me._id) {
- me.log("stop");
- return me._session.deleteClient({'clientId': me._id}).then(function() {
- me._id = null;
- return me;
- });
- }
- },
-
- toString : function() {
- return "["
- + [
- this.getMode().toUpperCase(),
- this.getDestination(),
- this._id ].join(',') + "]";
- }
- });
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/messaging/Destination.js
--- a/src/implab/messaging/Destination.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-define([ "dojo/_base/declare", "./Listener" ],
-
-function(declare, Listener) {
- return declare(null, {
- _session : null,
- _destination : null,
- _listenerClass : null,
-
- constructor : function(session, destination, options) {
- if (!session)
- throw new Error("A session is required");
- if (!destination)
- throw new Error("A destination is required");
-
- this._session = session;
- this._destination = destination;
- if (options) {
- if (options.listenerClass)
- this._listenerClass = options.listenerClass;
- }
- },
-
- listen : function(callback) {
- var factory = this._listenerClass || Listener;
- var listener = new factory(this._session, this._destination, {
- listener : callback
- });
- listener.start();
-
- return listener;
- }
-
- });
-});
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/messaging/Listener.js
--- a/src/implab/messaging/Listener.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-define([ "dojo/_base/declare", "dojo/_base/lang", "./Client" ],
-
-function(declare, lang, Client) {
- return declare([ Client ], {
- _listener : null,
-
- constructor : function(session, destination, options) {
- if (!options || !options.listener)
- throw new Error("A listener is required");
- this._listener = options.listener;
- if (options.transform)
- this._transform = options.transform;
- },
-
- getMode : function() {
- return "listener";
- },
-
- process : function(result) {
- switch (result.type) {
- case "message":
- try {
- this._handleMessage(result.message);
- } catch (ex) {
- var err = new Error("Failed to handle message");
- err.envelope = result.message;
- err.innerException = ex;
- this._handleError(err);
- }
- break;
- case "error":
- this._handleError(result.error);
- break;
- }
-
- },
-
- _transform : function(envelope) {
- return envelope;
- },
-
- _handleMessage : function(envelope) {
- this.log(
- "MESSAGE type = ${0}, headers = ${2}: ${1}",
- envelope.bodyType,
- envelope.body,
- JSON.stringify(envelope.headers));
- var data = this._transform(envelope);
- this._listener(data);
- this.emit("message", data);
- },
-
- _handleError : function(ex) {
- if (ex.innerException)
- this.error(
- "ERROR: ${0} -> ${1}",
- ex.message,
- ex.innerException.message);
- else
- this.error("ERROR: ${0}", ex.message);
- this.emit("error", ex);
- }
- });
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/messaging/Session.js
--- a/src/implab/messaging/Session.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,217 +0,0 @@
-define(
- [
- "dojo/_base/declare",
- "dojo/_base/lang",
- "dojo/request",
- "./Destination",
- "dojo/Evented",
- "dojo/Deferred",
- "../log/_LogMixin" ],
-
- function(declare, lang, request, Destination, Evented, Deferred, _LogMixin) {
-
- var cls = declare(
- [ Evented, _LogMixin ],
- {
- _id : null,
- _baseUrl : null,
- _destinations : null,
- _timeout : 100000,
- _clients : null,
- _started : null,
- _starting : false,
-
- constructor : function(baseUrl, options) {
- if (!baseUrl)
- throw new Error("baseUrl is required");
- options = options || {};
-
- this._baseUrl = baseUrl.replace(/\/*$/, "");
- this._destinations = {};
- this._pending = [];
- this._clients = {};
- if (options.timeout)
- this._timeout = options.timeout;
-
- this._started = new Deferred();
- },
-
- start : function() {
- if (this._starting)
- return this._started;
- this._starting = true;
-
- var me = this;
- me.log("START");
- request(this._baseUrl, {
- method : "POST",
- handleAs : "json"
- }).then(function(result) {
- me._id = result;
- me._emitConnected();
- me._poll();
- me._started.resolve(me);
- }, function(error) {
- me._emitError(error);
- me._started.reject(me);
- });
- return me._started.promise;
- },
-
- createClient : function(options) {
- if (!options || !options.destination || !options.mode)
- throw new Error("Invalid argument");
-
- var me = this;
-
- return me._started
- .then(function() {
- var url = me._makeUrl(me._id);
- me.log(
- "CREATE mode=${0}, destination=${1}",
- options.mode,
- options.destination);
-
- return request(url, {
- method : "POST",
- data : {
- mode : options.mode,
- destination : options.destination
- },
- handleAs : 'json'
- })
- .then(
- function(id) {
- me
- .log(
- "CLIENT id=${0}, mode=${1}, destination=${2}",
- id,
- options.mode,
- options.destination);
- me._clients[id] = options.client
- ? options.client
- : function(msg) {
- me
- .warn(
- "The client id=${0}, mode=${1}, destination=${2} isn't accepting mesages",
- id,
- options.mode,
- options.destination);
- };
- return id;
- });
- });
-
- },
-
- deleteClient : function(options) {
- if (!options || !options.clientId)
- throw new Error("Invalid argument");
-
- var me = this, id = options.clientId;
-
- return me._started.then(function() {
- var url = me._makeUrl(me._id, options.clientId);
-
- me.log("DELETE CLIENT ${0}", options.clientId);
-
- return request(url, {
- method : "DELETE",
- handleAs : 'json'
- }).then(function() {
- me.log("CLIENT DELETED ${0}", options.clientId);
- me._clients[id] = undefined;
- });
- });
- },
-
- _poll : function() {
- var me = this, url = this._makeUrl(this._id);
- me.log("POLL timeout=${0}", me._timeout);
- request(url, {
- method : "GET",
- handleAs : "json",
- query : {
- timeout : me._timeout
- }
- }).then(function(response) {
- me._handlePoll(response);
- me._poll();
- }, function(err) {
- me.error("POLL faield with ${0}", err);
- me._emitError(err);
- });
- },
-
- _handlePoll : function(response) {
- if (!response) {
- this.log("POLL response undefined, looks like a bug");
- return;
- }
- if (!response.results || !response.results.length) {
- this.log("POLL response is empty");
- return;
- }
-
- var results = response.results;
- this.log("POLL got ${0} results", results.length);
-
- for (var i = 0; i < results.length; i++) {
- var result = results[i];
- var client = this._clients[result.clientId];
- if (!client) {
- // TODO this could happen due to client isn't
- // registered yet
- this.error("Unknown client ${0}", result.clientId);
- continue;
- }
- client.call(this, result);
- }
- },
-
- _emitError : function(err) {
- this.emit("error", err);
- },
-
- _emitConnected : function() {
- var me = this;
- me.log("CONNECTED");
- me.emit("connected");
- },
-
- _makeUrl : function() {
- var parts = [ this._baseUrl ];
- for (var i = 0; i < arguments.length; i++)
- parts.push(arguments[i].replace(/\/*$/, ""));
- return parts.join('/');
- },
-
- queue : function(name) {
- return this._getDestination("queue://" + name);
- },
-
- topic : function(name) {
- return this._getDestination("topic://" + name);
- },
-
- _getDestination : function(uri) {
- if (uri in this._destinations)
- return this._destinations[uri];
-
- var dest = new Destination(this, uri);
- this._destinations[uri] = dest;
- return dest;
- },
-
- toString : function() {
- return [ "[", "SESSION ", this._id, "]" ].join(" ");
- }
- });
-
- cls.connect = function(url, options) {
- var session = new cls(url, options);
- return session.start();
- };
-
- return cls;
- });
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/safe.js
--- a/src/implab/safe.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,323 +0,0 @@
-define([],
-
- function () {
- var _create = Object.create,
- _keys = Object.keys;
-
- var safe = null;
- safe = {
- argumentNotNull: function (arg, name) {
- if (arg === null || arg === undefined)
- throw new Error("The argument " + name + " can't be null or undefined");
- },
-
- argumentNotEmptyString: function (arg, name) {
- if (typeof (arg) !== "string" || !arg.length)
- throw new Error("The argument '" + name + "' must be a not empty string");
- },
-
- argumentNotEmptyArray: function (arg, name) {
- if (!(arg instanceof Array) || !arg.length)
- throw new Error("The argument '" + name + "' must be a not empty array");
- },
-
- argumentOfType: function (arg, type, name) {
- if (!(arg instanceof type))
- throw new Error("The argument '" + name + "' type doesn't match");
- },
-
- isNull: function (arg) {
- return (arg === null || arg === undefined);
- },
-
- isPrimitive: function (arg) {
- return (arg === null || arg === undefined || typeof (arg) === "string" ||
- typeof (arg) === "number" || typeof (arg) === "boolean");
- },
-
- isInteger: function (arg) {
- return parseInt(arg) == arg;
- },
-
- isNumber: function (arg) {
- return parseFloat(arg) == arg;
- },
-
- isString: function (val) {
- return typeof (val) == "string" || val instanceof String;
- },
-
- isNullOrEmptyString: function (str) {
- if (str === null || str === undefined ||
- ((typeof (str) == "string" || str instanceof String) && str.length === 0))
- return true;
- },
-
- isNotEmptyArray: function (arg) {
- return (arg instanceof Array && arg.length > 0);
- },
-
- /**
- * Выполняет метод для каждого элемента массива, останавливается, когда
- * либо достигнут конец массива, либо функция cb вернула
- * значение.
- *
- * @param{Array | Object} obj массив элементов для просмотра
- * @param{Function} cb функция, вызываемая для каждого элемента
- * @param{Object} thisArg значение, которое будет передано в качестве
- * this в cb.
- * @returns Результат вызова функции cb, либо undefined
- * если достигнут конец массива.
- */
- each: function (obj, cb, thisArg) {
- safe.argumentNotNull(cb, "cb");
- var i, x;
- if (obj instanceof Array) {
- for (i = 0; i < obj.length; i++) {
- x = cb.call(thisArg, obj[i], i);
- if (x !== undefined)
- return x;
- }
- } else {
- var keys = _keys(obj);
- for (i = 0; i < keys.length; i++) {
- var k = keys[i];
- x = cb.call(thisArg, obj[k], k);
- if (x !== undefined)
- return x;
- }
- }
- },
-
- /**
- * Копирует свойства одного объекта в другой.
- *
- * @param{Any} dest объект в который нужно скопировать значения
- * @param{Any} src источник из которого будут копироваться значения
- * @tmpl{Object|Array} tmpl шаблон по которому будет происходить
- * копирование. Если шаблон является массивом
- * (список свойств), тогда значения этого массива
- * являются именами свойсвт которые будут
- * скопированы. Если шаблон является объектом (карта
- * преобразования имен свойств src->dst), тогда
- * копирование будет осуществляться только
- * собственных свойств источника, присутсвующих в
- * шаблоне, при этом значение свойства шаблона
- * является именем свойства в которое будет
- * произведено коприрование
- */
- mixin: function (dest, src, tmpl) {
- safe.argumentNotNull(dest, "dest");
- if (!src)
- return dest;
-
- var keys, i, p;
- if (arguments.length < 3) {
- keys = _keys(src);
- for (i = 0; i < keys.length; i++) {
- p = keys[i];
- dest[p] = src[p];
- }
- } else {
- if (tmpl instanceof Array) {
- for (i = 0; i < tmpl.length; i++) {
- p = tmpl[i];
- if (p in src)
- dest[p] = src[p];
- }
-
- } else {
- keys = _keys(src);
- for (i = 0; i < keys.length; i++) {
- p = keys[i];
- if (p in tmpl)
- dest[tmpl[p]] = src[p];
- }
- }
- }
- return dest;
- },
-
- /** Wraps the specified function to emulate an asynchronous execution.
- * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
- * @param{Function|String} fn [Required] Function wich will be wrapped.
- */
- async: function (fn, thisArg) {
- if (arguments.length == 2 && !(fn instanceof Function))
- fn = thisArg[fn];
-
- if (fn == null)
- throw new Error("The function must be specified");
-
- function wrapresult(x, e) {
- if (e) {
- return {
- then: function (cb, eb) {
- try {
- return eb ? wrapresult(eb(e)) : this;
- } catch (e2) {
- return wrapresult(null, e2);
- }
- }
- };
- } else {
- if (x && x.then)
- return x;
- return {
- then : function(cb) {
- try {
- return cb ? wrapresult(cb(x)) : this;
- } catch(e2) {
- return wrapresult(e2);
- }
- }
- };
- }
- }
-
- try {
- return wrapresult(fn.apply(thisArg, arguments));
- } catch (e) {
- return wrapresult(null, e);
- };
- },
-
- create: function () {
- if (console && console.warn)
- console.warn("implab/safe::create is deprecated use Object.create instead");
- _create.apply(this, arguments);
- },
-
- delegate: function (target, method) {
- if (!(method instanceof Function)) {
- this.argumentNotNull(target, "target");
- method = target[method];
- }
-
- if (!(method instanceof Function))
- throw new Error("'method' argument must be a Function or a method name");
-
- return function () {
- return method.apply(target, arguments);
- };
- },
-
- /**
- * Для каждого элемента массива вызывает указанную функцию и сохраняет
- * возвращенное значение в массиве результатов.
- *
- * @remarks cb может выполняться асинхронно, при этом одновременно будет
- * только одна операция.
- *
- * @async
- */
- pmap: function (items, cb) {
- safe.argumentNotNull(cb, "cb");
-
- if (items && items.then instanceof Function)
- return items.then(function (data) {
- return safe.pmap(data, cb);
- });
-
- if (safe.isNull(items) || !items.length)
- return items;
-
- var i = 0,
- result = [];
-
- function next() {
- var r, ri;
-
- function chain(x) {
- result[ri] = x;
- return next();
- }
-
- while (i < items.length) {
- r = cb(items[i], i);
- ri = i;
- i++;
- if (r && r.then) {
- return r.then(chain);
- } else {
- result[ri] = r;
- }
- }
- return result;
- }
-
- return next();
- },
-
- /**
- * Для каждого элемента массива вызывает указанную функцию, результаты
- * не сохраняются
- *
- * @remarks cb может выполняться асинхронно, при этом одновременно будет
- * только одна операция.
- * @async
- */
- pfor: function (items, cb) {
- safe.argumentNotNull(cb, "cb");
-
- if (items && items.then instanceof Function)
- return items.then(function (data) {
- return safe.pmap(data, cb);
- });
-
- if (safe.isNull(items) || !items.length)
- return items;
-
- var i = 0;
-
- function next() {
- while (i < items.length) {
- var r = cb(items[i], i);
- i++;
- if (r && r.then)
- return r.then(next);
- }
- }
-
- return next();
- },
-
- /**
- * Выбирает первый элемент из последовательности, или обещания, если в
- * качестве параметра используется обещание, оно должно вернуть массив.
- *
- * @param{Function} cb обработчик результата, ему будет передан первый
- * элемент последовательности в случае успеха
- * @param{Fucntion} err обработчик исключения, если массив пустой, либо
- * не массив
- *
- * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
- * обещание, либо первый элемент.
- * @async
- */
- first: function (sequence, cb, err) {
- if (sequence) {
- if (sequence.then instanceof Function) {
- return sequence.then(function (res) {
- return safe.first(res, cb, err);
- }, err);
- } else if (sequence && "length" in sequence) {
- if (sequence.length === 0) {
- if (err)
- return err(new Error("The sequence is empty"));
- else
- throw new Error("The sequence is empty");
- }
- return cb ? cb(sequence[0]) : sequence[0];
- }
- }
-
- if (err)
- return err(new Error("The sequence is required"));
- else
- throw new Error("The sequence is required");
- }
- };
-
- return safe;
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/text/format-compile.js
--- a/src/implab/text/format-compile.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,101 +0,0 @@
-define(
- [],
- function() {
- var map = {
- "\\{" : "&curlopen;",
- "\\}" : "&curlclose;",
- "&" : "&",
- "\\:" : ":"
- };
-
- var rev = {
- curlopen : "{",
- curlclose : "}",
- amp : "&",
- colon : ":"
- };
-
- var espaceString = function(s) {
- if (!s)
- return s;
- return "'" + s.replace(/('|\\)/g, "\\$1") + "'";
- };
-
- var encode = function(s) {
- if (!s)
- return s;
- return s.replace(/\\{|\\}|&|\\:/g, function(m) {
- return map[m] || m;
- });
- };
-
- var decode = function(s) {
- if (!s)
- return s;
- return s.replace(/&(\w+);/g, function(m, $1) {
- return rev[$1] || m;
- });
- };
-
- var subst = function(s) {
- var i = s.indexOf(":"), name, pattern;
- if (i >= 0) {
- name = s.substr(0, i);
- pattern = s.substr(i + 1);
- } else {
- name = s;
- }
-
- if (pattern)
- return [
- espaceString(decode(name)),
- espaceString(decode(pattern)) ];
- else
- return [ espaceString(decode(name)) ];
- };
-
- var compile = function(str) {
- if (!str)
- return function() {};
-
- var chunks = encode(str).split("{"), chunk;
-
- var code = [ "var result=[];" ];
-
- for (var i = 0; i < chunks.length; i++) {
- chunk = chunks[i];
-
- if (i === 0) {
- if (chunk)
- code.push("result.push(" + espaceString(decode(chunk)) +
- ");");
- } else {
- var len = chunk.indexOf("}");
- if (len < 0)
- throw new Error("Unbalanced substitution #" + i);
-
- code.push("result.push(subst(" +
- subst(chunk.substr(0, len)).join(",") + "));");
- if (chunk.length > len + 1)
- code.push("result.push(" +
- espaceString(decode(chunk.substr(len + 1))) + ");");
- }
- }
-
- code.push("return result.join('');");
-
- /* jshint -W054 */
- return new Function("subst", code.join("\n"));
- };
-
- var cache = {};
-
- return function(template) {
- var compiled = cache[template];
- if (!compiled) {
- compiled = compile(template);
- cache[template] = compiled;
- }
- return compiled;
- };
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/text/format.js
--- a/src/implab/text/format.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,87 +0,0 @@
-define([
- "../safe",
- "./format-compile",
- "dojo/number",
- "dojo/date/locale",
- "dojo/_base/array" ], function(safe, compile, number, date, array) {
-
- // {short,medium,full,long}-{date,time}
- var convert = function(value, pattern) {
- if (!pattern)
- return value.toString();
-
- if (pattern.toLocaleLowerCase() == "json") {
- var cache = [];
- return JSON.stringify(value, function(k, v) {
- if (!safe.isPrimitive(v)) {
- var id = array.indexOf(cache, v);
- if (id >= 0)
- return "@ref-" + id;
- else
- return v;
- } else {
- return v;
- }
- },2);
- }
-
- if (safe.isNumber(value)) {
- var nopt = {};
- if (pattern.indexOf("!") === 0) {
- nopt.round = -1;
- pattern = pattern.substr(1);
- }
- nopt.pattern = pattern;
- return number.format(value, nopt);
- } else if (value instanceof Date) {
- var m = pattern.match(/^(\w+)-(\w+)$/);
- if (m)
- return date.format(value, {
- selector : m[2],
- formatLength : m[1]
- });
- else if (pattern == "iso")
- return value.toISOString();
- else
- return date.format(value, {
- selector : "date",
- datePattern : pattern
- });
- } else {
- return value.toString(pattern);
- }
- };
-
- function formatter(format) {
- var data;
-
- if (arguments.length <= 1)
- return format;
-
- data = Array.prototype.slice.call(arguments, 1);
-
- var template = compile(format);
-
- return template(function(name, pattern) {
- var value = data[name];
- return !safe.isNull(value) ? convert(value, pattern) : "";
- });
- }
-
- formatter.compile = function(format) {
- var template = compile(format);
-
- return function() {
- var data = arguments;
-
- return template(function(name, pattern) {
- var value = data[name];
- return !safe.isNull(value) ? convert(value, pattern) : "";
- });
- };
- };
-
- formatter.convert = convert;
-
- return formatter;
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/implab/text/template-compile.js
--- a/src/implab/text/template-compile.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,134 +0,0 @@
-define(
- ["dojo/request", "./format", "../log/trace!"],
- function (request, format, trace) {
-
- // разбивает строку шаблона на токены, возвращает контекст для
- // дальнейшей обработки в visitTemplate
- var parseTemplate = function (str) {
- var tokens = str.split(/(<%=|\[%=|<%|\[%|%\]|%>)/);
- var pos = -1;
- var data = [],
- code = [];
-
- return {
- next: function () {
- pos++;
- return pos < tokens.length;
- },
- token: function () {
- return tokens[pos];
- },
- pushData: function () {
- var i = data.length;
- data.push.apply(data, arguments);
- return i;
- },
- pushCode : function() {
- var i = code.length;
- code.push.apply(code, arguments);
- return i;
- },
- compile: function () {
- var text = "var $p = [];\n" +
- "var print = function(){\n" +
- " $p.push(format.apply(null,arguments));\n" +
- "};\n" +
- // Introduce the data as local variables using with(){}
- "with(obj){\n" +
- code.join("\n") +
- "}\n" +
- "return $p.join('');";
-
- try {
- var compiled = new Function("obj, format, $data", text);
- /**
- * Функция форматирования по шаблону
- *
- * @type{Function}
- * @param{Object} obj объект с параметрами для подстановки
- */
- return function (obj) {
- return compiled(obj || {}, format, data);
- };
- } catch (e) {
- trace.error([e]);
- trace.log([text, data]);
- throw e;
- }
- }
- }
- };
-
- function visitTemplate(context) {
- while (context.next()) {
- switch (context.token()) {
- case "<%":
- case "[%":
- visitCode(context);
- break;
- case "<%=":
- case "[%=":
- visitInline(context);
- break;
- default:
- visitTextFragment(context);
- break;
- }
- }
- }
-
- function visitInline(context) {
- var code = ["$p.push("];
- while (context.next()) {
- if (context.token() == "%>" || context.token() == "%]")
- break;
- code.push(context.token());
- }
- code.push(");");
- context.pushCode(code.join(''));
- }
-
- function visitCode(context) {
- var code = [];
- while (context.next()) {
- if (context.token() == "%>" || context.token() == "%]")
- break;
- code.push(context.token());
- }
- context.pushCode(code.join(''));
- }
-
- function visitTextFragment(context) {
- var i = context.pushData(context.token());
- context.pushCode("$p.push($data["+i+"]);");
- }
-
- var compile = function (str) {
- if (!str)
- return function() { return "";};
-
- var ctx = parseTemplate(str);
- visitTemplate(ctx);
- return ctx.compile();
- };
-
- var cache = {};
-
- compile.load = function (id, require, callback) {
- var url = require.toUrl(id);
- if (url in cache) {
- callback(cache[url]);
- } else {
- request(url).then(compile).then(function (tc) {
- callback(cache[url] = tc);
- }, function (err) {
- require.signal("error", [{
- error: err,
- src: 'implab/text/template-compile'
- }]);
- });
- }
- };
-
- return compile;
- });
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 src/utest/store/mock.js
--- a/src/utest/store/mock.js Sat Jun 23 21:50:11 2018 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,95 +0,0 @@
-define([
- "dojo/_base/declare",
- "dojo/_base/lang",
- "dojo/request",
- "dojo/store/Memory",
- "dojo/Deferred",
- "dojo/store/util/QueryResults"
-
-], function (declare, lang, request, Memory, Deferred, QueryResults) {
- /**
- * @amdplugin
- * @usage
- *
- *
- * require([
- * "tests/store/mock!./data/sample.json"
- * ], function(Store) {
- * var store = new Store(); // will create a memory store
- * });
- *
- */
- var cache = {};
- return {
- load: function (id, require, callback) {
- var url = require.toUrl(id);
- if (url in cache) {
- callback(cache[url]);
- } else {
- request(url).then(function (data) {
- // handle result as text and parse it every time the
- // store
- // is created to get an independent copy
- var f = cache[url] = function (opts) {
- var store = new Memory(lang.mixin({
- data: JSON.parse(data),
- async: true,
- delay: 100
- }, opts || {}));
-
- declare.safeMixin(store, {
- query: function () {
- var results = this.inherited(arguments);
- if (this.async) {
- var d = new Deferred();
- setTimeout(function () {
- d.resolve(results);
- }, this.delay);
- return new QueryResults(d.promise);
- }
- return results;
- },
-
- get: function () {
- var results = this.inherited(arguments);
- if (this.async) {
- var d = new Deferred();
- setTimeout(function () {
- d.resolve(results);
- }, this.delay);
- return d.promise;
- }
- return results;
- },
-
- put: function () {
- var me = this;
-
- if (me.async) {
- var inherited = me.getInherited(arguments);
- var args = Array.prototype.slice.apply(arguments);
- var d = new Deferred();
-
- setTimeout(function () {
- d.resolve(inherited.apply(me, args));
- }, me.delay);
-
- return d.promise;
- }
- return me.inherited(arguments);
- }
- });
-
- return store;
- };
- callback(f);
- }, function (err) {
- require.signal("error", [{
- error: err,
- src: 'implab/store/mock'
- }]);
- });
- }
- }
- };
-});
\ No newline at end of file
diff -r d796bbbe558c -r acdcdf1a8d21 utest/src/js/utest/store/mock.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/utest/src/js/utest/store/mock.js Tue Jun 26 19:35:44 2018 +0300
@@ -0,0 +1,95 @@
+define([
+ "dojo/_base/declare",
+ "dojo/_base/lang",
+ "dojo/request",
+ "dojo/store/Memory",
+ "dojo/Deferred",
+ "dojo/store/util/QueryResults"
+
+], function (declare, lang, request, Memory, Deferred, QueryResults) {
+ /**
+ * @amdplugin
+ * @usage
+ *
+ *
+ * require([
+ * "tests/store/mock!./data/sample.json"
+ * ], function(Store) {
+ * var store = new Store(); // will create a memory store
+ * });
+ *
+ */
+ var cache = {};
+ return {
+ load: function (id, require, callback) {
+ var url = require.toUrl(id);
+ if (url in cache) {
+ callback(cache[url]);
+ } else {
+ request(url).then(function (data) {
+ // handle result as text and parse it every time the
+ // store
+ // is created to get an independent copy
+ var f = cache[url] = function (opts) {
+ var store = new Memory(lang.mixin({
+ data: JSON.parse(data),
+ async: true,
+ delay: 100
+ }, opts || {}));
+
+ declare.safeMixin(store, {
+ query: function () {
+ var results = this.inherited(arguments);
+ if (this.async) {
+ var d = new Deferred();
+ setTimeout(function () {
+ d.resolve(results);
+ }, this.delay);
+ return new QueryResults(d.promise);
+ }
+ return results;
+ },
+
+ get: function () {
+ var results = this.inherited(arguments);
+ if (this.async) {
+ var d = new Deferred();
+ setTimeout(function () {
+ d.resolve(results);
+ }, this.delay);
+ return d.promise;
+ }
+ return results;
+ },
+
+ put: function () {
+ var me = this;
+
+ if (me.async) {
+ var inherited = me.getInherited(arguments);
+ var args = Array.prototype.slice.apply(arguments);
+ var d = new Deferred();
+
+ setTimeout(function () {
+ d.resolve(inherited.apply(me, args));
+ }, me.delay);
+
+ return d.promise;
+ }
+ return me.inherited(arguments);
+ }
+ });
+
+ return store;
+ };
+ callback(f);
+ }, function (err) {
+ require.signal("error", [{
+ error: err,
+ src: 'implab/store/mock'
+ }]);
+ });
+ }
+ }
+ };
+});
\ No newline at end of file