@viewdo/dxp-story-cli/dist/app/services/TokenizationService.js

DXP Story Management CLI

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TokenizationService = void 0;
const typedi_1 = require("typedi");
const FileService_1 = require("./FileService");
const liquidjs_1 = require("liquidjs");
// Regex to match liquid tags {% ... %}
const liquidTagRegex = /{%[^%]*?%}/g;
// Regex used to find `live` tokens with {{}}
const liveTokens = /{{([\w]*[\w-_.,:$|']*)}}/gi;
// Replacement value for `live` tokens to `no-op` with ||
const liveTokenReplacement = "||$1||";
// Regex used to find verified tokens that liquid can parse
const verifiedTokens = /\[((?:experience|story|organization|user|app|api|xapi|system|action)\.[\w-.,:|']*(?:--[\w-.,:|']+)*)\]/gi;
// Regex used to find `live` tokens converted to `no-op`
const safeLiveTokens = /\|\|([\w]*[\w-_.,:$|']*)\|\|/gi;
// Replacement value for both liquid and `live` tokens
// Tokens that are 'no-op` are converted to use `{{}}` only after liquid has parsed
const tokenReplacement = "{{$1}}";
let TokenizationService = class TokenizationService {
    constructor() {
        this.fileService = typedi_1.Container.get(FileService_1.FileService);
        this.liquidEngine = new liquidjs_1.Liquid();
        this.registerFilters();
    }
    parseLiquidTemplate(filePath, values) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                let data = this.fileService.read(filePath);
                if (!data)
                    return Promise.reject(`File not found: ${filePath}`);
                data = this.tokenizeForLiquid(data);
                const context = {
                    xapi: {
                        url: 'http://localhost:8050/api'
                    },
                    experience: values,
                    story: values.story,
                    organization: values.organization
                };
                let result = yield this.liquidEngine.parseAndRender(data, context);
                return this.detokenizeForLiveTokens(result);
            }
            catch (err) {
                return Promise.reject(err);
            }
        });
    }
    replaceSquareBrackets(match) {
        const squareBracketRegex = /\[([\w.]+)\]/g;
        return match.replace(squareBracketRegex, '$1');
    }
    tokenizeForLiquid(data) {
        // First, preserve the live tokens by converting them to safe tokens
        data = data.replace(liveTokens, liveTokenReplacement);
        // Then, remove any additional token brackets from any tags
        data = data.replace(liquidTagRegex, this.replaceSquareBrackets);
        // Then replace the token brackets with the templating curly-braces
        data = data.replace(verifiedTokens, tokenReplacement);
        return data;
    }
    detokenizeForLiveTokens(data) {
        return data.replace(safeLiveTokens, tokenReplacement);
    }
    detokenizeData(data) {
        const htmlTemplateRegex = /\[story\.html\-templates\.([\w0-9]*)\.url\]/g;
        const _tokenReplace = (value) => {
            if (htmlTemplateRegex.test(value))
                return value.replace(htmlTemplateRegex, '/html-templates/$1.liquid');
            return value;
        };
        const _fixTemplateUrlProperties = (node) => {
            if (!node)
                return;
            Object.keys(node).forEach(key => {
                if (key == 'templateUrl') {
                    node[key] = _tokenReplace(node[key]);
                }
                if (typeof node[key] === 'object') {
                    _fixTemplateUrlProperties(node[key]);
                }
            });
        };
        _fixTemplateUrlProperties(data);
    }
    detokenize(content) {
        return content;
    }
    registerFilters() {
        this.liquidEngine.registerFilter('base64', (v) => {
            if (!v)
                return null;
            return Buffer.from(v, 'binary').toString('base64');
        });
        this.liquidEngine.registerFilter('clip', (v, length) => {
            if (!v)
                return null;
            return v.length <= length ? v : v.substring(0, length);
        });
    }
};
exports.TokenizationService = TokenizationService;
exports.TokenizationService = TokenizationService = __decorate([
    (0, typedi_1.Service)(),
    __metadata("design:paramtypes", [])
], TokenizationService);
//# sourceMappingURL=TokenizationService.js.map