@aj-shadow/actorjs-app 0.0.0-aj-beta.221

package/project/client/stores/plus-services-store.js

@@ -0,0 +1,267 @@
+
+'use strict';
+
+import { DataActionPlusServicesGet, DataActionPlusServicesBundleGet } from '../actions/action-plus-services/data-action-plus-services';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class PlusServicesStore extends StoreBaseData {
+  static TO_LOAD_STATUS_NOT_LOADED = 0;
+  static TO_LOAD_STATUS_LOADING = 1;
+  static TO_LOAD_STATUS_LOADED = 2;
+  
+  static LOAD_PART_PLUS_SERVICE = 0;
+  static LOAD_PART_DEPENDENCY = 1;
+  
+  constructor() {
+    super({
+      plusServices: new Map(),
+      dependencies: new Map()
+    });
+    this.dataToLoad = new Map();
+  }
+  
+  onInit() {
+    const loadedScripts = [...document.scripts].map((s) => {
+      let bundle = null;
+      if(s.src) {
+        const index = s.src.lastIndexOf('/');
+        if(-1 !== index) {
+          bundle = s.src.substring(index + 1);
+        }
+        return {
+          bundle: bundle,
+          name: s.dataset.name,
+          isLoaded: true
+        }
+      }
+    }).filter(src => src);
+    loadedScripts.forEach((loadedScript) => {
+      if(loadedScript.name) {
+        this.state.dependencies.set(loadedScript.name, loadedScript);
+      }
+    });
+    this.sendDataAction(new DataActionPlusServicesGet());
+  }
+  
+  onDataActionPlusServicesGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const plusServices = new Map();
+      response.data.forEach((plusService) => {
+        plusService.isLoaded = false;
+        const dependencies = plusService.dependencies;
+        plusService.dependencies = new Map();
+        dependencies.forEach((dependency) => {
+          plusService.dependencies.set(dependency.name, dependency);
+          dependency.isLoaded = this.state.dependencies.has(dependency.name);
+          if(!dependency.isLoaded) {
+            if(dependency.bundle) {
+              this._dataToLoadSet(plusService.name, dependency.bundle, 'js', PlusServicesStore.LOAD_PART_DEPENDENCY);
+              this.sendDataAction(new DataActionPlusServicesBundleGet(dependency.bundle, 'js', dependency.name, plusService.name));
+            }
+            if(dependency.cssBundle) {
+              this._dataToLoadSet(plusService.name, dependency.cssBundle, 'css', PlusServicesStore.LOAD_PART_DEPENDENCY);
+              this.sendDataAction(new DataActionPlusServicesBundleGet(dependency.cssBundle, 'css', dependency.name, plusService.name));
+            }
+          }
+        });
+        plusServices.set(plusService.name, plusService);
+        if(plusService.bundle) {
+          this._dataToLoadSet(plusService.name, plusService.bundle, 'js', PlusServicesStore.LOAD_PART_PLUS_SERVICE);
+          this.sendDataAction(new DataActionPlusServicesBundleGet(plusService.bundle, 'js', plusService.name, plusService.name));
+        }
+        if(plusService.cssBundle) {
+          this._dataToLoadSet(plusService.name, plusService.cssBundle, 'css', PlusServicesStore.LOAD_PART_PLUS_SERVICE);
+          this.sendDataAction(new DataActionPlusServicesBundleGet(plusService.cssBundle, 'css', plusService.name, plusService));
+        }
+      });
+      this.updateState({plusServices: {$set: plusServices}});
+    }
+  }
+  
+  onDataActionPlusServicesBundleGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const f = (production, data, done) => {
+        if(production) {
+          this._gunzipBrowser(new Uint8Array(data.data), done);
+        }
+        else {
+          done(null, data);
+        }
+      };
+      f(response.data[0], response.data[1], (err, data) => {
+        const loadedData = this.dataToLoad.get(action.bundle);
+        if(loadedData) {
+          loadedData.isLoaded = true;
+          loadedData.data = data;
+          this._handleData(action.plusServiceName);
+        }
+        else {
+          ddb.error('error: ', action.bundle, 'not found.');
+        }
+      });
+    }
+    else {
+      ddb.error('error: ', response);
+    }
+  }
+  
+  _dataToLoadSet(plusServiceName, name, type, part) {
+    if(!this.dataToLoad.has(name)) {
+      this.dataToLoad.set(name, {
+        plusServiceNames: new Set([plusServiceName]),
+        name,
+        data: null,
+        isLoaded: false,
+        type,
+        part,
+        status: PlusServicesStore.TO_LOAD_STATUS_NOT_LOADED
+      });
+    }
+    else {
+      this.dataToLoad.get(name).plusServiceNames.add(plusServiceName);
+    }
+  }
+  
+  _handleData(plusServiceName) {
+    for(const [key, value] of this.dataToLoad) {
+      if(!value.plusServiceNames.has(plusServiceName)) {
+        continue;
+      }
+      if(PlusServicesStore.TO_LOAD_STATUS_NOT_LOADED === value.status) {
+        if(value.data) {
+          value.status = PlusServicesStore.TO_LOAD_STATUS_LOADING;
+          this._loadData(value.name, value.data, value.type, (err) => {
+            value.status = PlusServicesStore.TO_LOAD_STATUS_LOADED;
+            value.plusServiceNames.forEach((plusServiceName) => {
+              process.nextTick(this._handleData.bind(this), plusServiceName);
+            });
+          });
+        }
+        else {
+          if(value.isLoaded) {
+            value.status = PlusServicesStore.TO_LOAD_STATUS_LOADED;
+            value.plusServiceNames.forEach((plusServiceName) => {
+              process.nextTick(this._handleData.bind(this), plusServiceName);
+            });
+          }
+          return;
+        }
+      }
+      else if(PlusServicesStore.TO_LOAD_STATUS_LOADING === value.status) {
+        return;
+      }
+      else if(PlusServicesStore.TO_LOAD_STATUS_LOADED === value.status) {
+        continue;
+      }
+    }
+    this.state.plusServices.forEach((plusService) => {
+      const name = plusService.name;
+      const values = [...this.dataToLoad.values()].filter(v => v.plusServiceNames.has(name));
+      const allLoaded = values.every(v => v.isLoaded);
+      if(allLoaded) {
+        this.updateContext(() => {
+          this.updateState({plusServices: (plusServices) => {
+            const plusService = plusServices.get(name);
+            const nextPlusService = this.deepCopy(plusService);
+            nextPlusService.isLoaded = true;
+            plusServices.set(name, nextPlusService);
+          }});
+        });
+      }
+    });
+  }
+  
+  _loadData(name, data, type, cb) {
+    if('js' === type) {
+      this._loadJavaScript(name, data, cb);
+    }
+    else if('css' === type) {
+      this._loadCss(name, data, cb)
+    }
+    else {
+      ddb.error('unknown type:', type);
+    }
+  }
+    
+  _gunzipBrowser(data, done) {
+    try {
+      const ds = new DecompressionStream("gzip");
+      const stream = new Blob([data]).stream().pipeThrough(ds);
+      new Response(stream).arrayBuffer()
+      .then((buf) => {
+        this.updateContext(() => {
+          done(null, new TextDecoder().decode(buf));
+        });
+      }).catch((err) => {
+        this.updateContext(() => {
+          done(err);
+        });
+      });
+    }
+    catch(err) {
+      done(err);
+    }
+  }
+  
+  _loadJavaScript(name, data, cb) {
+    const eventName = `ajEvent${name}`;
+    const handler = (e) => {
+      document.removeEventListener(eventName, handler);
+      cb(e.detail.error);
+    };
+    document.addEventListener(eventName, handler);
+    const script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.dataset.name = name;
+    script.dataset.type = "js";
+    script.text = `
+    try {
+      ${data}
+      document.dispatchEvent(
+        new CustomEvent('${eventName}', {
+          detail: { error: null }
+        })
+      );
+    } catch (err) {
+      document.dispatchEvent(
+        new CustomEvent('${eventName}', {
+          detail: { error: err }
+        })
+      );
+      throw err;
+    }
+  `;
+   document.body.appendChild(script);
+  }
+  
+  _loadCss(name, data, cb) {
+    const css = document.createElement('style');
+    css.type = 'text/css';
+    if(css.styleSheet) {
+      css.styleSheet.cssText = data;
+    }
+    else {
+      css.appendChild(document.createTextNode(data));
+    }
+    css.dataset.name = name;
+    css.dataset.type = "css";
+    document.head.appendChild(css);
+    process.nextTick(cb, null);
+  }
+    
+  // --- API ---
+  
+  isLoaded(name) {
+    const plusService = this.state.plusServices.get(name);
+    if(plusService) {
+      return plusService.isLoaded;
+    }
+    return false;
+  }
+}
+
+
+module.exports = PlusServicesStore.export(PlusServicesStore);

package/project/client/stores/repos-store.js

@@ -0,0 +1,160 @@
+
+'use strict';
+
+import { DataActionReposAnalyzeLocalReposGet, DataActionReposClone, DataActionReposGet, DataActionReposUpdate, DataActionReposVerifyGit } from '../actions/action-repos/data-action-repos';
+import MarkupRepos from 'z-abs-complayer-markup-client/client/markup/markup-repos/markup-repos';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class ReposStore extends StoreBaseData {
+  constructor() {
+    super({
+      handleRepos: false,
+      actorjsContentLocalExists: false,
+      actorjsDataLocalExists: false,
+      actorjsContentLocalRepos: [],
+      actorjsDataLocalRepos: [],
+      localContentUrl: '',
+      localDataUrl: '',
+      markup: {
+        definition: false,
+        content: undefined,
+        contentOriginal: undefined,
+        rows: undefined
+      },
+      progress: {
+        clone: false
+      },
+      error: {
+        error: false,
+        text: ''
+      },
+      gitConfigs: []
+    });
+  }
+    
+  _clearError() {
+    this.updateState({error: {error: { $set: false}}});
+    this.updateState({error: {text: { $set: ''}}});
+  }
+  
+  onActionReposAnalyzeLocalReposGet(action) {
+    this.sendDataAction(new DataActionReposAnalyzeLocalReposGet());
+    this._clearError();
+  }
+  
+  onActionReposGet(action) {
+    this.sendDataAction(new DataActionReposGet());
+    this._clearError();
+  }
+  
+  onActionReposClone(action) {
+    this.sendDataAction(new DataActionReposClone(action));
+    this.updateState({progress: {clone: { $set: true}}});
+    this._clearError();
+  }
+  
+  onActionReposVerifyGit(action) {
+    this.sendDataAction(new DataActionReposVerifyGit());
+  }
+  
+  onActionReposMarkup(action) {
+    let markup = MarkupRepos.stringify(this.state.reposContentLocal, this.state.actorjsContentLocalRepos);
+    this.updateState({markup: { definition: {$set: true}}});
+    this.updateState({markup: { content: {$set: markup}}});
+    this.updateState({markup: { contentOriginal: {$set: markup}}});
+  }
+  
+  onActionReposMarkupSave(action) {
+    const result = MarkupRepos.stringify(this.state.reposContentLocal, this.state.actorjsContentLocalRepos);
+    if(!result.success) {
+      this.updateState({markup: { rows: {$set: result.rows}}});
+    }
+    else {
+      this.sendDataAction(new DataActionReposUpdate(result.contentRepos, result.dataRepos));
+      this.clearMarkup();
+    }
+  }
+  
+  onActionReposMarkupCancel(action) {
+     this.clearMarkup();
+  }
+  
+  onActionReposMarkupChange(action) {
+    const result = MarkupRepos.parse(action.markup);
+    this.updateState({markup: { rows: {$set: result.rows}}});
+    this.updateState({markup: { content: {$set: action.markup}}});
+  }
+  
+  onActionTestCaseMarkupCopy() {
+    const markupTc = MarkupRepos.stringify(this.state.reposContentLocal, this.state.actorjsContentLocalRepos);
+    navigator.clipboard.writeText(markupTc).then(() => {}, () => {});
+  }
+  
+  onDataActionReposAnalyzeLocalReposGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const contentData = response.data[0];
+      const dataData = response.data[1];
+      const reposData = response.data[2];
+      this.updateState({actorjsContentLocalExists: { $set: contentData.isRepo}});
+      this.updateState({actorjsDataLocalExists: { $set: dataData.isRepo}});
+      this.updateState({handleRepos: { $set: !contentData.isRepo || !dataData.isRepo}});
+      if(reposData) {
+        this.updateState({actorjsContentLocalRepos: { $set: reposData.actorjsContentRepos}});
+        this.updateState({actorjsDataLocalRepos: { $set: reposData.actorjsDataRepos}});
+        this.updateState({localContentUrl: { $set: contentData.isRepo ? contentData.url : reposData.actorjsContentRepos[0]?.url}});
+        this.updateState({localDataUrl: { $set: dataData.isRepo ? dataData.url : reposData.actorjsDataRepos[0]?.url}});
+      }
+      else {
+        this.updateState({actorjsContentLocalRepos: { $set: []}});
+        this.updateState({actorjsDataLocalRepos: { $set: []}});
+        this.updateState({localContentUrl: { $set: ''}});
+        this.updateState({localDataUrl: { $set: ''}});
+      }
+    }
+    else {
+      this.updateState({error: {error: { $set: true}}});
+      this.updateState({error: {text: { $set: response.result.msg[0]}}});
+    }
+  }
+  
+  onDataActionReposGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const actorjsContentLocalExists = -1 !== response.data.actorjsContentRepos.find((repo) => {
+        return 'actorjs-content-local' === repo.name;
+      });
+      this.updateState({actorjsContentLocalExists: { $set: actorjsContentLocalExists}});
+      this.updateState({actorjsContentLocalRepos: { $set: response.data.actorjsContentRepos}});
+      const actorjsDataLocalExists = -1 !== response.data.actorjsDataRepos.find((repo) => {
+        return 'actorjs-data-local' === repo.name;
+      });
+      this.updateState({actorjsDataLocalExists: { $set: actorjsDataLocalExists}});
+      this.updateState({actorjsDataLocalRepos: { $set: response.data.actorjsDataRepos}});
+    }
+  }
+   
+  onDataActionReposClone(action) {
+    const response = action.getResponse();
+    this.updateState({progress: {clone: { $set: false}}});
+    if(response.isSuccess()) {
+      this.sendDataAction(new DataActionReposAnalyzeLocalReposGet());
+      this._clearError();
+    }
+    else {
+      this.updateState({error: {error: { $set: true}}});
+      this.updateState({error: {text: { $set: response.result.msg[0]}}});
+    }
+  }
+  
+  onDataActionReposVerifyGit(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({gitConfigs: { $set: response.data}});
+    }
+  }
+}
+
+
+module.exports = ReposStore.export(ReposStore);