@tolgee/core 2.8.2 → 3.0.0

package/lib/{handlers → wrappers}/WrappedHandler.js

@@ -1,18 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -50,17 +35,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { NodeHelper } from '../helpers/NodeHelper';
-import { AbstractHandler } from './AbstractHandler';
+import { NodeHandler } from './NodeHandler';
 import { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from '../Constants/Global';
-var WrappedHandler = /** @class */ (function (_super) {
-    __extends(WrappedHandler, _super);
-    function WrappedHandler(properties, translationHighlighter, textService, elementRegistrar) {
-        var _this = _super.call(this, properties, textService, elementRegistrar, translationHighlighter) || this;
-        _this.properties = properties;
-        _this.translationHighlighter = translationHighlighter;
-        _this.textService = textService;
-        _this.elementRegistrar = elementRegistrar;
-        return _this;
+var WrappedHandler = /** @class */ (function () {
+    function WrappedHandler(elementRegistrar, nodeHandler) {
+        this.elementRegistrar = elementRegistrar;
+        this.nodeHandler = nodeHandler;
     }
     WrappedHandler.prototype.handle = function (node) {
         return __awaiter(this, void 0, void 0, function () {
@@ -69,9 +49,9 @@ var WrappedHandler = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 xPath = "./descendant-or-self::*[@".concat(TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE, "]");
                 nodes = NodeHelper.evaluate(xPath, node);
-                filtered = this.filterRestricted(nodes);
+                filtered = this.nodeHandler.filterRestricted(nodes);
                 filtered.forEach(function (element) {
-                    var elementWithMeta = AbstractHandler.initParentElement(element);
+                    var elementWithMeta = NodeHandler.initParentElement(element);
                     elementWithMeta._tolgee.wrappedWithElementOnlyKey = element.getAttribute(TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE);
                     elementWithMeta._tolgee.wrappedWithElementOnlyDefaultHtml =
                         element.innerHTML;
@@ -82,6 +62,6 @@ var WrappedHandler = /** @class */ (function (_super) {
         });
     };
     return WrappedHandler;
-}(AbstractHandler));
+}());
 export { WrappedHandler };
 //# sourceMappingURL=WrappedHandler.js.map

package/lib/wrappers/WrappedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrappedHandler.js","sourceRoot":"","sources":["../../src/wrappers/WrappedHandler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAEzE;IACE,wBACU,gBAAkC,EAClC,WAAwB;QADxB,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,gBAAW,GAAX,WAAW,CAAa;IAC/B,CAAC;IAEE,+BAAM,GAAZ,UAAa,IAAU;;;;;gBACf,KAAK,GAAG,mCAA4B,kCAAkC,MAAG,CAAC;gBAC1E,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;gBACzC,QAAQ,GAAc,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAC3D,KAAkB,CACnB,CAAC;gBACF,QAAQ,CAAC,OAAO,CAAC,UAAC,OAAO;oBACvB,IAAM,eAAe,GAAG,WAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;oBAC/D,eAAe,CAAC,OAAO,CAAC,yBAAyB,GAAG,OAAO,CAAC,YAAY,CACtE,kCAAkC,CACnC,CAAC;oBACF,eAAe,CAAC,OAAO,CAAC,iCAAiC;wBACvD,OAAO,CAAC,SAAS,CAAC;oBACpB,KAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;gBAClD,CAAC,CAAC,CAAC;;;;KACJ;IACH,qBAAC;AAAD,CAAC,AAtBD,IAsBC"}

package/lib/wrappers/invisible/AttributeHandler.d.ts

@@ -0,0 +1,8 @@
+import { NodeHandler } from '../NodeHandler';
+import { Properties } from '../../Properties';
+export declare class AttributeHandler {
+    private properties;
+    private nodeHandler;
+    constructor(properties: Properties, nodeHandler: NodeHandler);
+    handle(node: Element): Promise<void>;
+}

package/lib/wrappers/invisible/AttributeHandler.js

@@ -0,0 +1,134 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { NodeHelper } from '../../helpers/NodeHelper';
+import { INVISIBLE_CHARACTERS } from '../../helpers/secret';
+var AttributeHandler = /** @class */ (function () {
+    function AttributeHandler(properties, nodeHandler) {
+        this.properties = properties;
+        this.nodeHandler = nodeHandler;
+    }
+    AttributeHandler.prototype.handle = function (node) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, tag, attributes, attributes_1, attributes_1_1, attribute, expression, nodes, e_1_1, e_2_1;
+            var e_2, _d, e_1, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _f.trys.push([0, 11, 12, 13]);
+                        _a = __values(Object.entries(this.properties.config.tagAttributes)), _b = _a.next();
+                        _f.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 10];
+                        _c = __read(_b.value, 2), tag = _c[0], attributes = _c[1];
+                        _f.label = 2;
+                    case 2:
+                        _f.trys.push([2, 7, 8, 9]);
+                        attributes_1 = (e_1 = void 0, __values(attributes)), attributes_1_1 = attributes_1.next();
+                        _f.label = 3;
+                    case 3:
+                        if (!!attributes_1_1.done) return [3 /*break*/, 6];
+                        attribute = attributes_1_1.value;
+                        expression = "descendant-or-self::".concat(tag, "/@").concat(attribute, "[contains(., '").concat(INVISIBLE_CHARACTERS[0], "')]");
+                        nodes = NodeHelper.evaluate(expression, node);
+                        return [4 /*yield*/, this.nodeHandler.handleNodes(nodes)];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5:
+                        attributes_1_1 = attributes_1.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _f.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (attributes_1_1 && !attributes_1_1.done && (_e = attributes_1.return)) _e.call(attributes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_2_1 = _f.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AttributeHandler;
+}());
+export { AttributeHandler };
+//# sourceMappingURL=AttributeHandler.js.map

package/lib/wrappers/invisible/AttributeHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeHandler.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/AttributeHandler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D;IACE,0BACU,UAAsB,EACtB,WAAwB;QADxB,eAAU,GAAV,UAAU,CAAY;QACtB,gBAAW,GAAX,WAAW,CAAa;IAC/B,CAAC;IAEE,iCAAM,GAAZ,UAAa,IAAa;;;;;;;;wBACQ,KAAA,SAAA,MAAM,CAAC,OAAO,CAC5C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,aAAa,CACrC,CAAA;;;;wBAFU,KAAA,mBAAiB,EAAhB,GAAG,QAAA,EAAE,UAAU,QAAA;;;;wBAGD,8BAAA,SAAA,UAAU,CAAA,CAAA;;;;wBAAvB,SAAS;wBACZ,UAAU,GAAG,8BAAuB,GAAG,eAAK,SAAS,2BAAiB,oBAAoB,CAAC,CAAC,CAAC,QAAK,CAAC;wBACnG,KAAK,GAAuB,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;wBACxE,qBAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,EAAA;;wBAAzC,SAAyC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAG/C;IACH,uBAAC;AAAD,CAAC,AAjBD,IAiBC"}

package/lib/wrappers/invisible/Coder.d.ts

@@ -0,0 +1,7 @@
+import { TranslationParams, Unwrapped } from '../../types';
+export declare class Coder {
+    private keyMemory;
+    private defaultMemory;
+    unwrap(text: string): Promise<Unwrapped>;
+    wrap(key: string, _params?: TranslationParams, defaultValue?: string | undefined, translation?: string | undefined): string;
+}

package/lib/wrappers/invisible/Coder.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { decodeFromText, encodeMessage, removeSecrets, stringToCodePoints, } from '../../helpers/secret';
+import { ValueMemory } from './ValueMemory';
+var Coder = /** @class */ (function () {
+    function Coder() {
+        this.keyMemory = new ValueMemory();
+        this.defaultMemory = new ValueMemory();
+    }
+    Coder.prototype.unwrap = function (text) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keysAndParams, messages, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                keysAndParams = [];
+                messages = decodeFromText(text);
+                messages.forEach(function (msg) {
+                    var _a = __read(stringToCodePoints(msg), 2), keyCode = _a[0], defaultCode = _a[1];
+                    var key = _this.keyMemory.numberToValue(keyCode);
+                    var defaultValue = defaultCode !== undefined
+                        ? _this.defaultMemory.numberToValue(defaultCode)
+                        : undefined;
+                    keysAndParams.push({
+                        key: key,
+                        params: undefined,
+                        defaultValue: defaultValue,
+                    });
+                });
+                result = removeSecrets(text);
+                if (keysAndParams.length) {
+                    return [2 /*return*/, { text: result, keys: keysAndParams }];
+                }
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    Coder.prototype.wrap = function (key, _params, defaultValue, translation) {
+        if (_params === void 0) { _params = {}; }
+        if (defaultValue === void 0) { defaultValue = undefined; }
+        if (translation === void 0) { translation = undefined; }
+        var codes = [this.keyMemory.valueToNumber(key)];
+        if (defaultValue) {
+            codes.push(this.defaultMemory.valueToNumber(defaultValue));
+        }
+        return ((translation || defaultValue || '') +
+            encodeMessage(String.fromCodePoint.apply(String, __spreadArray([], __read(codes), false))));
+    };
+    return Coder;
+}());
+export { Coder };
+//# sourceMappingURL=Coder.js.map

package/lib/wrappers/invisible/Coder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Coder.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/Coder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EACL,cAAc,EACd,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;IAAA;QACU,cAAS,GAAG,IAAI,WAAW,EAAE,CAAC;QAC9B,kBAAa,GAAG,IAAI,WAAW,EAAE,CAAC;IA4C5C,CAAC;IA1CO,sBAAM,GAAZ,UAAa,IAAY;;;;;gBACjB,aAAa,GAAG,EAAoB,CAAC;gBACrC,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;gBAEtC,QAAQ,CAAC,OAAO,CAAC,UAAC,GAAG;oBACb,IAAA,KAAA,OAAyB,kBAAkB,CAAC,GAAG,CAAC,IAAA,EAA/C,OAAO,QAAA,EAAE,WAAW,QAA2B,CAAC;oBACvD,IAAM,GAAG,GAAG,KAAI,CAAC,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;oBAClD,IAAM,YAAY,GAChB,WAAW,KAAK,SAAS;wBACvB,CAAC,CAAC,KAAI,CAAC,aAAa,CAAC,aAAa,CAAC,WAAW,CAAC;wBAC/C,CAAC,CAAC,SAAS,CAAC;oBAChB,aAAa,CAAC,IAAI,CAAC;wBACjB,GAAG,EAAE,GAAG;wBACR,MAAM,EAAE,SAAS;wBACjB,YAAY,cAAA;qBACb,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBAEG,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;gBAEnC,IAAI,aAAa,CAAC,MAAM,EAAE;oBACxB,sBAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,EAAC;iBAC9C;gBACD,sBAAO,SAAS,EAAC;;;KAClB;IAEM,oBAAI,GAAX,UACE,GAAW,EACX,OAA+B,EAC/B,YAA4C,EAC5C,WAA2C;QAF3C,wBAAA,EAAA,YAA+B;QAC/B,6BAAA,EAAA,wBAA4C;QAC5C,4BAAA,EAAA,uBAA2C;QAE3C,IAAM,KAAK,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;QAClD,IAAI,YAAY,EAAE;YAChB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC;SAC5D;QAED,OAAO,CACL,CAAC,WAAW,IAAI,YAAY,IAAI,EAAE,CAAC;YACnC,aAAa,CAAC,MAAM,CAAC,aAAa,OAApB,MAAM,2BAAkB,KAAK,WAAE,CAC9C,CAAC;IACJ,CAAC;IACH,YAAC;AAAD,CAAC,AA9CD,IA8CC"}

package/lib/wrappers/invisible/ContentHandler.d.ts

@@ -0,0 +1,6 @@
+import { NodeHandler } from '../NodeHandler';
+export declare class ContentHandler {
+    private nodeHandler;
+    constructor(nodeHandler: NodeHandler);
+    handle(node: Node): Promise<void>;
+}

package/lib/{services/DependencyStore.test.js → wrappers/invisible/ContentHandler.js}

@@ -34,34 +34,30 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-jest.dontMock('./DependencyStore');
-import { getMockedInstance } from '@testFixtures/mocked';
-import { mocked } from 'ts-jest/utils';
-import { Properties } from '../Properties';
-import { DependencyStore } from './DependencyStore';
-describe('DependecyStore', function () {
-    var dependencyStore;
-    var config = {
-        apiKey: 'yep',
-    };
-    beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            dependencyStore = new DependencyStore(config);
-            getMockedInstance(Properties).config.targetElement = document.body;
-            return [2 /*return*/];
-        });
-    }); });
-    afterEach(function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            jest.clearAllMocks();
-            return [2 /*return*/];
+import { NodeHelper } from '../../helpers/NodeHelper';
+import { INVISIBLE_CHARACTERS } from '../../helpers/secret';
+var ContentHandler = /** @class */ (function () {
+    function ContentHandler(nodeHandler) {
+        this.nodeHandler = nodeHandler;
+    }
+    ContentHandler.prototype.handle = function (node) {
+        return __awaiter(this, void 0, void 0, function () {
+            var xPath, nodes, filtered;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        xPath = "./descendant-or-self::text()[contains(., '".concat(INVISIBLE_CHARACTERS[0], "')]");
+                        nodes = NodeHelper.evaluate(xPath, node);
+                        filtered = this.nodeHandler.filterRestricted(nodes);
+                        return [4 /*yield*/, this.nodeHandler.handleNodes(filtered)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         });
-    }); });
-    it('inits translation service', function () {
-        expect(mocked(dependencyStore.translationService).initStatic).toBeCalledTimes(1);
-    });
-    it('sets config to properties', function () {
-        expect(dependencyStore.properties.config).toEqual(config);
-    });
-});
-//# sourceMappingURL=DependencyStore.test.js.map
+    };
+    return ContentHandler;
+}());
+export { ContentHandler };
+//# sourceMappingURL=ContentHandler.js.map

package/lib/wrappers/invisible/ContentHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentHandler.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/ContentHandler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D;IACE,wBAAoB,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IAAG,CAAC;IAE1C,+BAAM,GAAZ,UAAa,IAAU;;;;;;wBACf,KAAK,GAAG,oDAA6C,oBAAoB,CAAC,CAAC,CAAC,QAAK,CAAC;wBAClF,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;wBACzC,QAAQ,GAAW,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,KAAe,CAAC,CAAC;wBAE5E,qBAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAA;;wBAA5C,SAA4C,CAAC;;;;;KAC9C;IACH,qBAAC;AAAD,CAAC,AAVD,IAUC"}

package/lib/wrappers/invisible/CoreHandler.d.ts

@@ -0,0 +1,10 @@
+import { ContentHandler } from './ContentHandler';
+import { AttributeHandler } from './AttributeHandler';
+import { WrappedHandler } from '../WrappedHandler';
+export declare class CoreHandler {
+    private textHandler;
+    private attributeHandler;
+    private wrappedHandler;
+    constructor(textHandler: ContentHandler, attributeHandler: AttributeHandler, wrappedHandler: WrappedHandler);
+    handleSubtree(target: Element): Promise<void>;
+}

package/lib/{services/__mocks__/CoreService.js → wrappers/invisible/CoreHandler.js}

@@ -34,16 +34,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import classMock from '@testFixtures/classMock';
-var moduleMock = jest.genMockFromModule('../CoreService');
-export var CoreService = classMock(function () { return ({
-    getApiKeyDetails: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, {
-                    scopes: ['translations.edit', 'keys.edit'],
-                    projectId: 0,
-                }];
+var CoreHandler = /** @class */ (function () {
+    function CoreHandler(textHandler, attributeHandler, wrappedHandler) {
+        this.textHandler = textHandler;
+        this.attributeHandler = attributeHandler;
+        this.wrappedHandler = wrappedHandler;
+    }
+    CoreHandler.prototype.handleSubtree = function (target) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.attributeHandler.handle(target)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.textHandler.handle(target)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.wrappedHandler.handle(target)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         });
-    }); }),
-}); }, moduleMock.CoreService);
-//# sourceMappingURL=CoreService.js.map
+    };
+    return CoreHandler;
+}());
+export { CoreHandler };
+//# sourceMappingURL=CoreHandler.js.map

package/lib/wrappers/invisible/CoreHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreHandler.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/CoreHandler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;IACE,qBACU,WAA2B,EAC3B,gBAAkC,EAClC,cAA8B;QAF9B,gBAAW,GAAX,WAAW,CAAgB;QAC3B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,mBAAc,GAAd,cAAc,CAAgB;IACrC,CAAC;IAES,mCAAa,GAA1B,UAA2B,MAAe;;;;4BACxC,qBAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;wBAC3C,qBAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAA;;wBAArC,SAAqC,CAAC;wBACtC,qBAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,EAAA;;wBAAxC,SAAwC,CAAC;;;;;KAC1C;IACH,kBAAC;AAAD,CAAC,AAZD,IAYC"}

package/lib/wrappers/invisible/InvisibleWrapper.d.ts

@@ -0,0 +1,18 @@
+import { Properties } from '../../Properties';
+import { ElementRegistrar } from '../../services/ElementRegistrar';
+import { TranslationParams } from '../../types';
+import { AbstractWrapper } from '../AbstractWrapper';
+export declare class InvisibleWrapper implements AbstractWrapper {
+    private coder;
+    private coreHandler;
+    private attributeHandler;
+    private wrappedHandler;
+    private textHandler;
+    private nodeHandler;
+    constructor(properties: Properties, elementRegistrar: ElementRegistrar);
+    handleText(node: Element): Promise<void>;
+    handleSubtree(node: Element): Promise<void>;
+    handleAttribute(node: Element): Promise<void>;
+    wrap(key: string, params?: TranslationParams, defaultValue?: string | undefined, translation?: string): string;
+    unwrap(text: string): Promise<import("../../types").Unwrapped>;
+}

package/lib/wrappers/invisible/InvisibleWrapper.js

@@ -0,0 +1,37 @@
+import { NodeHandler } from '../NodeHandler';
+import { AttributeHandler } from './AttributeHandler';
+import { Coder } from './Coder';
+import { CoreHandler } from './CoreHandler';
+import { ContentHandler } from './ContentHandler';
+import { WrappedHandler } from '../WrappedHandler';
+var InvisibleWrapper = /** @class */ (function () {
+    function InvisibleWrapper(properties, elementRegistrar) {
+        this.coder = new Coder();
+        this.nodeHandler = new NodeHandler(properties, elementRegistrar, this);
+        this.textHandler = new ContentHandler(this.nodeHandler);
+        this.attributeHandler = new AttributeHandler(properties, this.nodeHandler);
+        this.wrappedHandler = new WrappedHandler(elementRegistrar, this.nodeHandler);
+        this.coreHandler = new CoreHandler(this.textHandler, this.attributeHandler, this.wrappedHandler);
+    }
+    InvisibleWrapper.prototype.handleText = function (node) {
+        return this.textHandler.handle(node);
+    };
+    InvisibleWrapper.prototype.handleSubtree = function (node) {
+        return this.coreHandler.handleSubtree(node);
+    };
+    InvisibleWrapper.prototype.handleAttribute = function (node) {
+        return this.attributeHandler.handle(node);
+    };
+    InvisibleWrapper.prototype.wrap = function (key, params, defaultValue, translation) {
+        if (params === void 0) { params = {}; }
+        if (defaultValue === void 0) { defaultValue = undefined; }
+        if (translation === void 0) { translation = ''; }
+        return this.coder.wrap(key, params, defaultValue, translation);
+    };
+    InvisibleWrapper.prototype.unwrap = function (text) {
+        return this.coder.unwrap(text);
+    };
+    return InvisibleWrapper;
+}());
+export { InvisibleWrapper };
+//# sourceMappingURL=InvisibleWrapper.js.map

package/lib/wrappers/invisible/InvisibleWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvisibleWrapper.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/InvisibleWrapper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD;IAOE,0BAAY,UAAsB,EAAE,gBAAkC;QACpE,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;QACvE,IAAI,CAAC,WAAW,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACxD,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3E,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CACtC,gBAAgB,EAChB,IAAI,CAAC,WAAW,CACjB,CAAC;QACF,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAChC,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,cAAc,CACpB,CAAC;IACJ,CAAC;IAEM,qCAAU,GAAjB,UAAkB,IAAa;QAC7B,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAEM,wCAAa,GAApB,UAAqB,IAAa;QAChC,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAEM,0CAAe,GAAtB,UAAuB,IAAa;QAClC,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAEM,+BAAI,GAAX,UACE,GAAW,EACX,MAA8B,EAC9B,YAA4C,EAC5C,WAAgB;QAFhB,uBAAA,EAAA,WAA8B;QAC9B,6BAAA,EAAA,wBAA4C;QAC5C,4BAAA,EAAA,gBAAgB;QAEhB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC;IACjE,CAAC;IAEM,iCAAM,GAAb,UAAc,IAAY;QACxB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IACH,uBAAC;AAAD,CAAC,AA/CD,IA+CC"}

package/lib/wrappers/invisible/ValueMemory.d.ts

@@ -0,0 +1,5 @@
+export declare class ValueMemory {
+    private values;
+    valueToNumber(key: string): number;
+    numberToValue(num: number): string;
+}

package/lib/wrappers/invisible/ValueMemory.js

@@ -0,0 +1,19 @@
+var ValueMemory = /** @class */ (function () {
+    function ValueMemory() {
+        this.values = [];
+    }
+    ValueMemory.prototype.valueToNumber = function (key) {
+        var index = this.values.indexOf(key);
+        if (index === -1) {
+            index = this.values.length;
+            this.values.push(key);
+        }
+        return index;
+    };
+    ValueMemory.prototype.numberToValue = function (num) {
+        return this.values[num];
+    };
+    return ValueMemory;
+}());
+export { ValueMemory };
+//# sourceMappingURL=ValueMemory.js.map

package/lib/wrappers/invisible/ValueMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueMemory.js","sourceRoot":"","sources":["../../../src/wrappers/invisible/ValueMemory.ts"],"names":[],"mappings":"AAAA;IAAA;QACU,WAAM,GAAa,EAAE,CAAC;IAchC,CAAC;IAZQ,mCAAa,GAApB,UAAqB,GAAW;QAC9B,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YAChB,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;YAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACvB;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,mCAAa,GAApB,UAAqB,GAAW;QAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IACH,kBAAC;AAAD,CAAC,AAfD,IAeC"}

package/lib/wrappers/text/AttributeHandler.d.ts

@@ -0,0 +1,8 @@
+import { NodeHandler } from '../NodeHandler';
+import { Properties } from '../../Properties';
+export declare class AttributeHandler {
+    private properties;
+    private nodeHandler;
+    constructor(properties: Properties, nodeHandler: NodeHandler);
+    handle(node: Element): Promise<void>;
+}

package/lib/{handlers → wrappers/text}/AttributeHandler.js

@@ -1,18 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -76,17 +61,11 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { AbstractHandler } from './AbstractHandler';
-import { NodeHelper } from '../helpers/NodeHelper';
-var AttributeHandler = /** @class */ (function (_super) {
-    __extends(AttributeHandler, _super);
-    function AttributeHandler(properties, textService, elementRegistrar, translationHighlighter) {
-        var _this = _super.call(this, properties, textService, elementRegistrar, translationHighlighter) || this;
-        _this.properties = properties;
-        _this.textService = textService;
-        _this.elementRegistrar = elementRegistrar;
-        _this.translationHighlighter = translationHighlighter;
-        return _this;
+import { NodeHelper } from '../../helpers/NodeHelper';
+var AttributeHandler = /** @class */ (function () {
+    function AttributeHandler(properties, nodeHandler) {
+        this.properties = properties;
+        this.nodeHandler = nodeHandler;
     }
     AttributeHandler.prototype.handle = function (node) {
         return __awaiter(this, void 0, void 0, function () {
@@ -115,7 +94,7 @@ var AttributeHandler = /** @class */ (function (_super) {
                         attribute = attributes_1_1.value;
                         expression = "descendant-or-self::".concat(tag, "/@").concat(attribute, "[contains(., '").concat(inputPrefix, "') and contains(., '").concat(inputSuffix, "')]");
                         nodes = NodeHelper.evaluate(expression, node);
-                        return [4 /*yield*/, this.handleNodes(nodes)];
+                        return [4 /*yield*/, this.nodeHandler.handleNodes(nodes)];
                     case 5:
                         _f.sent();
                         _f.label = 6;
@@ -153,6 +132,6 @@ var AttributeHandler = /** @class */ (function (_super) {
         });
     };
     return AttributeHandler;
-}(AbstractHandler));
+}());
 export { AttributeHandler };
 //# sourceMappingURL=AttributeHandler.js.map