@aj-shadow/z-abs-complayer-markup-client 0.0.0-aj-beta.221

package/project/client/markup/markup-content/markup-content-documents.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentDocumentsGlobal = require('../../data/data-content/data-content-documents-global');
+const DataContentDocumentsLocal = require('../../data/data-content/data-content-documents-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentDocuments {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentDocumentsLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentDocumentsGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentDocumentsGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentDocumentsLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentDocuments();

package/project/client/markup/markup-content/markup-content-image.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentImageGlobal = require('../../data/data-content/data-content-image-global');
+const DataContentImageLocal = require('../../data/data-content/data-content-image-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentImage {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentImageLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentImageGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentImageGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentImageLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentImage();

package/project/client/markup/markup-content/markup-content-other.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentOtherGlobal = require('../../data/data-content/data-content-other-global');
+const DataContentOtherLocal = require('../../data/data-content/data-content-other-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentOther {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentOtherLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentOtherGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentOtherGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentOtherLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentOther();

package/project/client/markup/markup-content/markup-content-text.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentTextGlobal = require('../../data/data-content/data-content-text-global');
+const DataContentTextLocal = require('../../data/data-content/data-content-text-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentText {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentTextLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentTextGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentTextGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentTextLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentText();

package/project/client/markup/markup-content/markup-content-video.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentVideoGlobal = require('../../data/data-content/data-content-video-global');
+const DataContentVideoLocal = require('../../data/data-content/data-content-video-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentVideo {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentVideoLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentVideoGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentVideoGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentVideoLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentVideo();

package/project/client/markup/markup-dependencies/markup-dependencies.js

@@ -0,0 +1,30 @@
+
+'use strict';
+
+const DataDependencies = require('../../data/data-dependencies/data-dependencies');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupDependencies {
+  stringify(dataDependencies) {
+    return `\n${MarkupTableKeyValue.stringify(new DataDependencies(), dataDependencies, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      dependencies: MarkupTableKeyValue.parse(DataDependencies, objectTables.objects)
+    };
+  }
+}
+
+
+module.exports = new MarkupDependencies();

package/project/client/markup/markup-documentation/markup-documentation-anchor.js

@@ -0,0 +1,37 @@
+
+'use strict';
+
+import GuidGenerator from 'z-abs-corelayer-cs/clientServer/guid-generator';
+
+
+class MarkupDocumentationAnchor {
+  constructor() {
+    this.key = 'ANCHOR';
+    this.type = 'markup_anchor';
+  }
+  
+  stringify(dataAnchor) {
+    return `${this.key}={"id":"${dataAnchor.id}","visible":${dataAnchor.visible}}`;
+  }
+  
+  parse(markup) {
+    let dataAnchor = null;
+    try {
+      dataAnchor = JSON.parse(markup);
+    } 
+    catch(err) {}
+    if(dataAnchor && dataAnchor.id) {
+      if(undefined === dataAnchor.visible || 'boolean' !== typeof dataAnchor.visible) {
+        dataAnchor.visible = false;
+      }
+      return dataAnchor;
+    }
+    return {
+      id: GuidGenerator.create(),
+      visible: true
+    };
+  }
+}
+
+
+module.exports = new MarkupDocumentationAnchor() ;

package/project/client/markup/markup-documentation/markup-documentation-api-status.js

@@ -0,0 +1,67 @@
+
+'use strict';
+
+
+class MarkupDocumentationApiStatus {
+  constructor() {
+    this.key = 'API-STATUS';
+    this.type = 'markup_api_status';
+  }
+  
+  stringify(dataDocStatus) {
+    let status = '';
+    if(MarkupDocumentationApiStatus.DEPRECATED === dataDocStatus.status) {
+      status = 'DEPRECATED';
+    }
+    else if(MarkupDocumentationApiStatus.EXPERIMENTAL === dataDocStatus.status) {
+      status = 'EXPERIMENTAL';
+    }
+    else if(MarkupDocumentationApiStatus.STABLE === dataDocStatus.status) {
+      status = 'STABLE';
+    }
+    else if(MarkupDocumentationApiStatus.LEGACY === dataDocStatus.status) {
+      status = 'LEGACY';
+    }
+    else {
+      status = 'DEPRECATED';
+    }
+    return `${this.key}=${status}, ${dataDocStatus.comment}`;
+  }
+  
+  parse(markup) {
+    const parameters = markup.split(',');
+    parameters.forEach((parameter, index) => {
+      parameters[index] = parameter.trim();
+    });
+    let status = 0;
+    if(1 <= parameters.length) {
+      const parameter = parameters[0];
+      if('DEPRECATED' === parameter) {
+        status = MarkupDocumentationApiStatus.DEPRECATED;
+      }
+      else if('EXPERIMENTAL' === parameter) {
+        status = MarkupDocumentationApiStatus.EXPERIMENTAL;
+      }
+      else if('STABLE' === parameter) {
+        status = MarkupDocumentationApiStatus.STABLE;
+      }
+      else if('LEGACY' === parameter) {
+        status = MarkupDocumentationApiStatus.LEGACY;
+      }
+      else {
+        status = MarkupDocumentationApiStatus.DEPRECATED;
+      }
+    }
+    return {
+      status: status,
+      comment: 2 <= parameters.length ? parameters[1] : ''
+    };
+  }
+}
+
+MarkupDocumentationApiStatus.DEPRECATED = 0;
+MarkupDocumentationApiStatus.EXPERIMENTAL = 1;
+MarkupDocumentationApiStatus.STABLE = 2;
+MarkupDocumentationApiStatus.LEGACY = 3;
+
+module.exports = new MarkupDocumentationApiStatus() ;

package/project/client/markup/markup-documentation/markup-documentation-code.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+
+class MarkupDocumentationCode {
+  markupName() {
+    return 'javascript';
+  }
+  
+  stringify(code) {
+    return code;
+  }
+  
+  parse(markup) {
+    return markup;
+  }
+}
+
+
+module.exports = new MarkupDocumentationCode();

package/project/client/markup/markup-documentation/markup-documentation-div.js

@@ -0,0 +1,34 @@
+
+'use strict';
+
+import GuidGenerator from 'z-abs-corelayer-cs/clientServer/guid-generator';
+
+
+class MarkupDocumentationDiv {
+  constructor() {
+    this.key = 'DIV';
+    this.type = 'markup_div';
+  }
+  
+  stringify(dataAnchor) {
+    return `${this.key}={"id":"${dataAnchor.id}","style":${JSON.stringify(dataAnchor.style)}}`;
+  }
+  
+  parse(markup) {
+    let dataAnchor = null;
+    try {
+      dataAnchor = JSON.parse(markup);
+    } 
+    catch(err) {}
+    if(dataAnchor && dataAnchor.id) {
+      return dataAnchor;
+    }
+    return {
+      id: GuidGenerator.create(),
+      style: ''
+    };
+  }
+}
+
+
+module.exports = new MarkupDocumentationDiv() ;

package/project/client/markup/markup-documentation/markup-documentation-documentation-status.js

@@ -0,0 +1,67 @@
+
+'use strict';
+
+
+class MarkupDocumentationDocumentationStatus {
+  constructor() {
+    this.key = 'DOC-STATUS';
+    this.type = 'markup_documentation_status';
+  }
+  
+  stringify(dataDocStatus) {
+    let status = '';
+    if(MarkupDocumentationDocumentationStatus.NOT_YET === dataDocStatus.status) {
+      status = 'NOT-YET';
+    }
+    else if(MarkupDocumentationDocumentationStatus.PARTLY === dataDocStatus.status) {
+      status = 'PARTLY';
+    }
+    else if(MarkupDocumentationDocumentationStatus.MOSTLY === dataDocStatus.status) {
+      status = 'MOSTLY';
+    }
+    else if(MarkupDocumentationDocumentationStatus.FULLY === dataDocStatus.status) {
+      status = 'FULLY';
+    }
+    else {
+      status = 'NOT-YET';
+    }
+    return `${this.key}=${status}, ${dataDocStatus.comment}`;
+  }
+  
+  parse(markup) {
+    const parameters = markup.split(',');
+    parameters.forEach((parameter, index) => {
+      parameters[index] = parameter.trim();
+    });
+    let status = 0;
+    if(1 <= parameters.length) {
+      const parameter = parameters[0];
+      if('NOT-YET' === parameter) {
+        status = MarkupDocumentationDocumentationStatus.NOT_YET;
+      }
+      else if('PARTLY' === parameter) {
+        status = MarkupDocumentationDocumentationStatus.PARTLY;
+      }
+      else if('MOSTLY' === parameter) {
+        status = MarkupDocumentationDocumentationStatus.MOSTLY;
+      }
+      else if('FULLY' === parameter) {
+        status = MarkupDocumentationDocumentationStatus.FULLY;
+      }
+      else {
+        status = MarkupDocumentationDocumentationStatus.NOT_YET;
+      }
+    }
+    return {
+      status: status,
+      comment: 2 <= parameters.length ? parameters[1] : ''
+    };
+  }
+}
+
+MarkupDocumentationDocumentationStatus.NOT_YET = 0;
+MarkupDocumentationDocumentationStatus.PARTLY = 1;
+MarkupDocumentationDocumentationStatus.MOSTLY = 2;
+MarkupDocumentationDocumentationStatus.FULLY = 3;
+
+module.exports = new MarkupDocumentationDocumentationStatus() ;

package/project/client/markup/markup-documentation/markup-documentation-embed.js

@@ -0,0 +1,23 @@
+
+'use strict';
+
+
+class MarkupDocumentationEmbed {
+  constructor() {
+    this.key = 'EMBED';
+    this.type = 'markup_embed';
+  }
+  
+  stringify(dataEmbed) {
+    return `${this.key}=${dataEmbed.path}`;
+  }
+  
+  parse(markup) {
+    return {
+      path: markup
+    };
+  }
+}
+
+
+module.exports = new MarkupDocumentationEmbed() ;

package/project/client/markup/markup-documentation/markup-documentation-html.js

@@ -0,0 +1,139 @@
+
+'use strict';
+
+const MarkupParseHelper = require('../markup-parse-helper');
+const DataHtmlAnchor = require('../../data/data-html/data-html-anchor');
+const DataHtmlButton = require('../../data/data-html/data-html-button');
+const DataHtmlToolbar = require('../../data/data-html/data-html-toolbar');
+const DataHtmlBr = require('../../data/data-html/data-html-br');
+const DataHtmlLog = require('../../data/data-html/data-html-log');
+const DataHtmlLogStart = require('../../data/data-html/data-html-log-start');
+const DataHtmlLogStop = require('../../data/data-html/data-html-log-stop');
+
+
+class MarkupDocumentationHtml {
+  markupName() {
+    return 'object';
+  }
+  
+  stringify(dataHtmls) {
+    let stringified = '';
+    dataHtmls.forEach((dataHtml) => {
+      if('anchor' === dataHtml.type) {
+        stringified += `\n[anchor](${dataHtml.link})`;
+      }
+      else if('button' === dataHtml.type) {
+        stringified += `\n[button](${dataHtml.icon}, ${dataHtml.colorMark}, ${dataHtml.text})`; 
+      }
+      else if('toolbar' === dataHtml.type) {
+        ddb.writeln('stringify - toolbar');
+        if(dataHtml.buttons) {
+          stringified += `\n[toolbar](${dataHtml.buttons})`; 
+        }
+        else {
+          stringified += `\n[toolbar]()`; 
+        }
+      }
+      else if('br' === dataHtml.type) {
+        stringified += `\n[br]`;
+      }
+      else if('log' === dataHtml.type) {
+        stringified += `\n[log](${dataHtml.logType}, ${dataHtml.date}, ${dataHtml.actor}, ${dataHtml.log}, ${dataHtml.fileName})`;
+      }
+      else if('log_start' === dataHtml.type) {
+        stringified += `\n[log_start](${dataHtml.date})`;
+      }
+      else if('log_end' === dataHtml.type) {
+        stringified += `\n[log_end](${dataHtml.result}, ${dataHtml.duration})`;
+      }
+    });
+    return stringified;
+  }
+  
+  parse(markup) {
+    let objects = [];
+    let rows = MarkupParseHelper.getRows(markup);
+    rows.forEach((row) => {
+      if(row.startsWith('[anchor]')) {
+        this._parseAnchor(objects, row.trim());
+      } 
+      else if(row.startsWith('[button]')) {
+        this._parseButton(objects, row.trim());
+      }
+      else if(row.startsWith('[toolbar]')) {
+        this._parseToolbar(objects, row.trim());
+      }
+      else if(row.startsWith('[br]')) {
+        objects.push(new DataHtmlBr());
+      }
+      else if(row.startsWith('[log]')) {
+        this._parseLog(objects, row.trim());
+      }
+      else if(row.startsWith('[log_start]')) {
+        this._parseLogStart(objects, row.trim());
+      }
+      else if(row.startsWith('[log_end]')) {
+        this._parseLogStop(objects, row.trim());
+      }
+    });
+    return objects;
+  }
+  
+  _parseAnchor(objects, row) {
+    let parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    if(undefined !== parameterNames) {
+      objects.push(new DataHtmlAnchor(...parameterNames));
+    }
+  }
+  
+  _parseButton(objects, row) {
+    let parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    for(let i = 0; i < parameterNames.length; ++i) {
+      parameterNames[i] = parameterNames[i].trim();
+    }
+    if(parameterNames) {
+      objects.push(new DataHtmlButton(...parameterNames));
+    }
+  }
+  
+  _parseToolbar(objects, row) {
+    const parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    for(let i = 0; i < parameterNames.length; ++i) {
+      parameterNames[i] = parameterNames[i].trim();
+    }
+    objects.push(new DataHtmlToolbar(...parameterNames));
+  }
+  
+  _parseLog(objects, row) {
+    let parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    parameterNames.forEach((parameterName, index) => {
+      parameterNames[index] = parameterName.trim();
+    });
+    if(undefined !== parameterNames) {
+      objects.push(new DataHtmlLog(...parameterNames));
+    }
+  }
+  
+  _parseLogStart(objects, row) {
+    let parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    parameterNames.forEach((parameterName, index) => {
+      parameterNames[index] = parameterName.trim();
+    });
+    if(undefined !== parameterNames) {
+      objects.push(new DataHtmlLogStart(...parameterNames));
+    }
+  }
+
+  _parseLogStop(objects, row) {
+    let parameterNames = row.slice(row.indexOf('(') + 1, row.lastIndexOf(')')).split(',');
+    parameterNames.forEach((parameterName, index) => {
+      parameterNames[index] = parameterName.trim();
+    });
+    if(undefined !== parameterNames) {
+      objects.push(new DataHtmlLogStop(...parameterNames));
+    }
+  }
+}
+
+
+module.exports = new MarkupDocumentationHtml();

package/project/client/markup/markup-documentation/markup-documentation-ie.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+
+class MarkupDocumentationIe {
+  constructor() {
+    this.key = 'IE';
+    this.type = 'markup_ie';
+  }
+  
+  stringify(dataIe) {
+    return `${this.key}=${dataIe}`;
+  }
+  
+  parse(markup) {
+    return markup;
+  }
+}
+
+
+module.exports = new MarkupDocumentationIe() ;

package/project/client/markup/markup-documentation/markup-documentation-image.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+const DataImage = require('../../data/data-image/data-image');
+
+
+class MarkupDocumentationImage {
+  constructor() {
+    this.key = 'IMAGE';
+    this.type = 'markup_image';
+  }
+  
+  stringify(dataImage) {
+    return `${this.key}=${this._stringifyParameters(dataImage)}`;
+  }
+  
+  _stringifyParameters(dataImage) {
+    let params = '';
+    const parameters = Object.keys(dataImage);
+    parameters.forEach((parameter) => {
+      const value = dataImage[parameter];
+      if(undefined !== value && '' !== value) {
+        params += `${parameter}: ${value}, `;
+      }
+    });
+    return params;
+  }
+  
+  parse(markup) {
+    const dataImage = new DataImage();
+    const parameters = [];
+    const parametersRaw = markup.split(',');
+    parametersRaw.forEach((parameterRaw) => {
+      const split = parameterRaw.split(':');
+      if(2 === split.length) {
+        const parameterName = split[0].trim();
+        const parameterValue = split[1].trim();
+        dataImage.addParameter(parameterName, parameterValue);
+      }
+    });
+    return dataImage;
+  }
+}
+
+
+module.exports = new MarkupDocumentationImage() ;

package/project/client/markup/markup-documentation/markup-documentation-lab.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupDocumentationLab {
+  stringify(lab) {
+    return lab;
+  }
+  
+  parse(markup) {
+    return markup;
+  }
+}
+
+
+module.exports = new MarkupDocumentationLab();