@dao42/d42paas-front 0.4.1 → 0.4.6

package/src/enum/FExtension.ts

@@ -0,0 +1,168 @@
+export enum FExtension {
+  erb = 'erb',
+  ru = 'ruby',
+  ejs = 'html',
+  json = 'json',
+  abap = 'abap',
+  cls = 'apex',
+  azcli = 'azcli',
+  bat = 'bat',
+  cmd = 'bat',
+  c = 'c',
+  h = 'c',
+  mligo = 'cameligo',
+  clj = 'clojure',
+  cljs = 'clojure',
+  cljc = 'clojure',
+  edn = 'clojure',
+  coffee = 'coffeescript',
+  cpp = 'cpp',
+  cc = 'cpp',
+  cxx = 'cpp',
+  hpp = 'cpp',
+  hh = 'cpp',
+  hxx = 'cpp',
+  cs = 'csharp',
+  csx = 'csharp',
+  cake = 'csharp',
+  css = 'css',
+  dart = 'dart',
+  dockerfile = 'dockerfile',
+  ecl = 'ecl',
+  fs = 'fsharp',
+  fsi = 'fsharp',
+  ml = 'fsharp',
+  mli = 'fsharp',
+  fsx = 'fsharp',
+  fsscript = 'fsharp',
+  go = 'go',
+  graphql = 'graphql',
+  gql = 'graphql',
+  handlebars = 'handlebars',
+  hbs = 'handlebars',
+  tf = 'hcl',
+  tfvars = 'hcl',
+  hcl = 'hcl',
+  html = 'html',
+  htm = 'html',
+  shtml = 'html',
+  xhtml = 'html',
+  mdoc = 'html',
+  jsp = 'html',
+  asp = 'html',
+  aspx = 'html',
+  jshtm = 'html',
+  ini = 'ini',
+  properties = 'ini',
+  gitconfig = 'ini',
+  java = 'java',
+  jav = 'java',
+  js = 'javascript',
+  es6 = 'javascript',
+  jsx = 'javascript',
+  mjs = 'javascript',
+  jl = 'julia',
+  kt = 'kotlin',
+  less = 'less',
+  lex = 'lexon',
+  lua = 'lua',
+  m3 = 'm3',
+  i3 = 'm3',
+  mg = 'm3',
+  ig = 'm3',
+  md = 'markdown',
+  markdown = 'markdown',
+  mdown = 'markdown',
+  mkdn = 'markdown',
+  mkd = 'markdown',
+  mdwn = 'markdown',
+  mdtxt = 'markdown',
+  mdtext = 'markdown',
+  s = 'mips',
+  dax = 'msdax',
+  msdax = 'msdax',
+  m = 'c',
+  pas = 'pascal',
+  p = 'pascal',
+  pp = 'pascal',
+  ligo = 'pascaligo',
+  pl = 'perl',
+  php = 'php',
+  php4 = 'php',
+  php5 = 'php',
+  phtml = 'php',
+  ctp = 'php',
+  dats = 'postiats',
+  sats = 'postiats',
+  hats = 'postiats',
+  pq = 'powerquery',
+  pqm = 'powerquery',
+  ps1 = 'powershell',
+  psm1 = 'powershell',
+  psd1 = 'powershell',
+  jade = 'pug',
+  pug = 'pug',
+  py = 'python',
+  rpy = 'python',
+  pyw = 'python',
+  cpy = 'python',
+  gyp = 'python',
+  gypi = 'python',
+  r = 'r',
+  rhistory = 'r',
+  rmd = 'r',
+  rprofile = 'r',
+  rt = 'r',
+  cshtml = 'razor',
+  redis = 'redis',
+  rst = 'restructuredtext',
+  rb = 'ruby',
+  rbx = 'ruby',
+  rjs = 'ruby',
+  gemspec = 'ruby',
+  rs = 'rust',
+  rlib = 'rust',
+  sb = 'sb',
+  scala = 'scala',
+  sc = 'scala',
+  sbt = 'scala',
+  scm = 'scheme',
+  ss = 'scheme',
+  sch = 'scheme',
+  rkt = 'scheme',
+  scss = 'scss',
+  sh = 'shell',
+  bash = 'shell',
+  aes = 'sophia',
+  sol = 'sol',
+  sql = 'sql',
+  st = 'st',
+  iecst = 'st',
+  iecplc = 'st',
+  lc3lib = 'st',
+  swift = 'swift',
+  sv = 'systemverilog',
+  svh = 'systemverilog',
+  tcl = 'tcl',
+  twig = 'twig',
+  ts = 'typescript',
+  tsx = 'typescript',
+  vb = 'vb',
+  v = 'verilog',
+  vh = 'verilog',
+  xml = 'xml',
+  dtd = 'xml',
+  ascx = 'xml',
+  csproj = 'xml',
+  config = 'xml',
+  wxi = 'xml',
+  wxl = 'xml',
+  wxs = 'xml',
+  xaml = 'xml',
+  svg = 'xml',
+  svgz = 'xml',
+  opf = 'xml',
+  xsl = 'xml',
+  yaml = 'yaml',
+  yml = 'yaml',
+}

package/src/helpers/collections/IoClient.tsx

@@ -0,0 +1,314 @@
+// import { openDB } from 'idb';
+// import { omit, pick } from 'lodash';
+// import { Client, Selection, TextOperation } from 'ot';
+// import { useOT } from '~/hooks';
+// import { oTStore } from '~/stores';
+// import { setEditorOT } from './idb';
+
+import { omit, pick } from 'lodash';
+import { TextOperation } from 'ot';
+import { useOT } from '~/hooks';
+import { oTStore } from '~/stores';
+// import { setEditorOT } from './idb';
+
+// import { openDB } from 'idb';
+// import { omit, pick } from 'lodash';
+// import { Client, Selection, TextOperation } from 'ot';
+// import { useOT } from '~/hooks';
+// import { oTStore } from '~/stores';
+// import { setEditorOT } from './idb';
+
+export function IoClient(this: any, revision) {
+  this.revision = revision; // the next expected revision number
+  this.state = synchronized_; // start state
+  this.operation = [];
+  this.receiveOperation = [];
+  this.io = useOT.getState().socket;
+}
+
+IoClient.prototype.setState = function (state) {
+  this.state = state;
+};
+
+// Call this method when the user changes the document.
+IoClient.prototype.applyClient = function (operation) {
+  this.operation = operation;
+  this.setState(this.state.applyClient(this, operation));
+};
+
+// Call this method with a new operation from the server
+IoClient.prototype.applyServer = function (operation) {
+  this.revision++;
+  // debugger;
+  this.setState(this.state.applyServer(this, operation));
+};
+
+IoClient.prototype.serverAck = function () {
+  // debugger;
+  this.revision++;
+  this.setState(this.state.serverAck(this));
+};
+
+IoClient.prototype.serverReconnect = function () {
+  if (typeof this.state.resend === 'function') {
+    this.state.resend(this);
+  }
+};
+
+// Transforms a selection from the latest known server state to the current
+// client state. For example, if we get from the server the information that
+// another user's cursor is at position 3, but the server hasn't yet received
+// our newest operation, an insertion of 5 characters at the beginning of the
+// document, the correct position of the other user's cursor in our current
+// document is 8.
+IoClient.prototype.transformSelection = function (selection) {
+  return this.state.transformSelection(selection);
+};
+
+IoClient.prototype.insertOTForDB = (obj) => {
+  // setEditorOT(obj.ot.revision, pick(obj.ot, 'file', 'operation'));
+  // await db.put('editor', pick(obj.ot, 'file', 'operation'), obj.ot.revision);
+  // await db.add('favourite-number', obj, 'price');
+};
+
+// Override this method.
+IoClient.prototype.sendOperation = function (
+  revision: number,
+  operation: TextOperation,
+) {
+  throw new Error('sendOperation must be defined in child class');
+};
+// Override this method.
+IoClient.prototype.applyOperation = function (operation) {
+  // oTStore.getState().setOperation(operation);
+
+  this.receiveOperation = operation;
+  // console.log('operation is coming back', operation);
+  // throw new Error('applyOperation must be defined in child class');
+  // this.serverAck();
+};
+
+// In the 'Synchronized' state, there is no pending operation that the client
+// has sent to the server.
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function Synchronized() {}
+IoClient.Synchronized = Synchronized;
+
+Synchronized.prototype.applyClient = function (client, operation) {
+  // When the user makes an edit, send the operation to the server and
+  // switch to the 'AwaitingConfirm' state
+  // debugger;
+  client.sendOperation(client.revision, operation);
+  return new AwaitingConfirm(operation);
+};
+
+Synchronized.prototype.applyServer = function (client, operation) {
+  // When we receive a new operation from the server, the operation can be
+  // simply applied to the current document
+  // debugger;
+  client.applyOperation(operation);
+  return this;
+};
+
+Synchronized.prototype.serverAck = function (client) {
+  throw new Error('There is no pending operation.');
+};
+
+// Nothing to do because the latest server state and client state are the same.
+Synchronized.prototype.transformSelection = function (x) {
+  return x;
+};
+
+// Singleton
+const synchronized_ = new Synchronized();
+
+// In the 'AwaitingConfirm' state, there's one operation the client has sent
+// to the server and is still waiting for an acknowledgement.
+function AwaitingConfirm(this: any, outstanding) {
+  // Save the pending operation
+  this.outstanding = outstanding;
+}
+IoClient.AwaitingConfirm = AwaitingConfirm;
+
+AwaitingConfirm.prototype.applyClient = function (client, operation) {
+  // When the user makes an edit, don't send the operation immediately,
+  // instead switch to 'AwaitingWithBuffer' state
+  return new AwaitingWithBuffer(this.outstanding, operation);
+};
+
+AwaitingConfirm.prototype.applyServer = function (client, operation) {
+  // This is another client's operation. Visualization:
+  //
+  //                   /\
+  // this.outstanding /  \ operation
+  //                 /    \
+  //                 \    /
+  //  pair[1]         \  / pair[0] (new outstanding)
+  //  (can be applied  \/
+  //  to the client's
+  //  current document)
+  const pair = operation.constructor.transform(this.outstanding, operation);
+  client.applyOperation(pair[1]);
+  return new AwaitingConfirm(pair[0]);
+};
+
+AwaitingConfirm.prototype.serverAck = function (client) {
+  // The client's operation has been acknowledged
+  // => switch to synchronized state
+  return synchronized_;
+};
+
+AwaitingConfirm.prototype.transformSelection = function (selection) {
+  return selection.transform(this.outstanding);
+};
+
+AwaitingConfirm.prototype.resend = function (client) {
+  // The confirm didn't come because the client was disconnected.
+  // Now that it has reconnected, we resend the outstanding operation.
+  client.sendOperation(client.revision, this.outstanding);
+};
+
+// In the 'AwaitingWithBuffer' state, the client is waiting for an operation
+// to be acknowledged by the server while buffering the edits the user makes
+function AwaitingWithBuffer(this: any, outstanding, buffer) {
+  // Save the pending operation and the user's edits since then
+  this.outstanding = outstanding;
+  this.buffer = buffer;
+}
+IoClient.AwaitingWithBuffer = AwaitingWithBuffer;
+
+AwaitingWithBuffer.prototype.applyClient = function (client, operation) {
+  // Compose the user's changes onto the buffer
+  const newBuffer = this.buffer.compose(operation);
+  return new AwaitingWithBuffer(this.outstanding, newBuffer);
+};
+
+AwaitingWithBuffer.prototype.applyServer = function (client, operation) {
+  // Operation comes from another client
+  //
+  //                       /\
+  //     this.outstanding /  \ operation
+  //                     /    \
+  //                    /\    /
+  //       this.buffer /  \* / pair1[0] (new outstanding)
+  //                  /    \/
+  //                  \    /
+  //          pair2[1] \  / pair2[0] (new buffer)
+  // the transformed    \/
+  // operation -- can
+  // be applied to the
+  // client's current
+  // document
+  //
+  // * pair1[1]
+  const transform = operation.constructor.transform;
+  const pair1 = transform(this.outstanding, operation);
+  const pair2 = transform(this.buffer, pair1[1]);
+  client.applyOperation(pair2[1]);
+  return new AwaitingWithBuffer(pair1[0], pair2[0]);
+};
+
+AwaitingWithBuffer.prototype.serverAck = function (client) {
+  // The pending operation has been acknowledged
+  // => send buffer
+  client.sendOperation(client.revision, this.buffer);
+  return new AwaitingConfirm(this.buffer);
+};
+
+AwaitingWithBuffer.prototype.transformSelection = function (selection) {
+  return selection.transform(this.outstanding).transform(this.buffer);
+};
+
+AwaitingWithBuffer.prototype.resend = function (client) {
+  // The confirm didn't come because the client was disconnected.
+  // Now that it has reconnected, we resend the outstanding operation.
+  client.sendOperation(client.revision, this.outstanding);
+};
+
+// export default Client;
+
+// export class IoClient extends Client {
+//   constructor(revision) {
+//     super(revision);
+//     // return ioClient;
+//   }
+//   revision: number;
+//   state: Client.Synchronized;
+//   io = useOT.getState().socket;
+
+//   setState(state: Client.Synchronized): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   applyClient(operation: TextOperation): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   applyServer(operation: TextOperation): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   serverAck(): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   serverReconnect(): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   transformSelection(selection: Selection): Selection {
+//     throw new Error('Method not implemented.');
+//   }
+//   sendOperation(revision: number, operation: TextOperation): void {
+//     console.log('调用监听');
+
+//     this.insertOTForDB({
+//       ot: {
+//         operation,
+//         revision,
+//         file: {
+//           ...omit(oTStore.getState().file, 'value'),
+//           // valueAndPos,
+//         },
+//         userInfo: userStore.getState().userInfo,
+//       },
+//     });
+//     this.io.emit(
+//       'editFile',
+//       // blob,
+//       JSON.stringify({
+//         ot: {
+//           operation,
+//           revision,
+//           file: {
+//             ...omit(oTStore.getState().file, 'value'),
+//             // valueAndPos,
+//           },
+//           userInfo: userStore.getState().userInfo,
+//         },
+//       }),
+//     );
+
+//     // throw new Error('Method not implemented.');
+//   }
+//   async insertOTForDB(obj) {
+//     setEditorOT(obj.ot.revision, pick(obj.ot, 'file', 'operation'));
+//     // await db.put('editor', pick(obj.ot, 'file', 'operation'), obj.ot.revision);
+//     // await db.add('favourite-number', obj, 'price');
+//   }
+//   applyOperation(operation: TextOperation): void {
+//     throw new Error('Method not implemented.');
+//   }
+//   // sendOperation = (revision, operation) => {
+//   //   this.io.emit(
+//   //     'editFile',
+//   //     // blob,
+//   //     JSON.stringify({
+//   //       ot: {
+//   //         operation,
+//   //         revision,
+//   //         file: {
+//   //           ...omit(oTStore.getState().file, 'value'),
+//   //           // valueAndPos,
+//   //         },
+//   //         userInfo: userStore.getState().userInfo,
+//   //       },
+//   //     }),
+//   //   );
+//   // };
+// }

package/src/helpers/collections/idb.tsx

@@ -0,0 +1,186 @@
+import { DBSchema, IDBPDatabase, openDB } from 'idb';
+import { oTStore } from '~/stores';
+import { v4 as uuidv4 } from 'uuid';
+import { omit, pick } from 'lodash';
+const crdtInfo = {
+  timestamp: '',
+  editor: new Map(),
+  selection: new Map(),
+  terminal: new Map(),
+  console: new Map(),
+  file: new Map(),
+  media: new Map(),
+};
+export const daopaasDB = openDB('daopaas', 1, {
+  upgrade(db) {
+    db.createObjectStore('crdts');
+    db.createObjectStore('oTStore');
+    db.createObjectStore('files');
+    db.createObjectStore('replayFiles');
+    db.createObjectStore('users');
+    db.createObjectStore('media');
+  },
+});
+
+export const GenerateDB = async (db_name, length = 1, obj) => {
+  return openDB(db_name, length, {
+    upgrade(db) {
+      db.createObjectStore(obj);
+    },
+  });
+};
+
+export async function setReplaySource(val, status?: string) {
+  // const dao = await daopaasDB;
+
+  const { CRDTInfo, appStatus, globalData } = oTStore.getState();
+
+  if (appStatus === 'replay') return;
+
+  // crdtInfo.timestamp = CRDTInfo.timestamp as string;
+
+  // crdtInfo.editor.set(
+  //   val.userInfo.uuid,
+  //   val.editor ? val.editor : crdtInfo.editor.get(val.userInfo.uuid),
+  // );
+
+  // crdtInfo.file.set(
+  //   val.userInfo.uuid,
+  //   val.file
+  //     ? omit(val.file, 'value')
+  //     : omit(crdtInfo.file.get(val.userInfo.uuid), 'value'),
+  // );
+
+  // crdtInfo.selection.set(
+  //   val.userInfo.uuid,
+  //   val.selection ? val.selection : crdtInfo.selection.get(val.userInfo.uuid),
+  // );
+
+  // crdtInfo.terminal.set(
+  //   val.userInfo.uuid,
+  //   val.terminal ? val.terminal : crdtInfo.terminal.get(val.userInfo.uuid),
+  // );
+
+  // crdtInfo.console.set(
+  //   val.userInfo.uuid,
+  //   val.console ? val.console : crdtInfo.console.get(val.userInfo.uuid),
+  // );
+
+  // crdtInfo.media.set(
+  //   val.userInfo.uuid,
+  //   val.media ? val.media : crdtInfo.media.get(val.userInfo.uuid),
+  // );
+
+  // const valTime = val.timestamp + '.' + (await dao.count('crdts'));
+  // return dao.put('crdts', val, val.timestamp + '.' + uuidv4().split('-')[0]);
+  // if (globalData.isRecording) {
+  return (await daopaasDB).put(
+    'crdts',
+    // crdtInfo,
+    {
+      ...val,
+      userInfo: pick(val.userInfo, ['uuid', 'role']),
+      file: omit(val.file, 'value'),
+    },
+    val.timestamp + '.' + uuidv4().split('-')[0],
+  );
+  // }
+}
+
+export const GetDB = async (db_name, key, obj_name) => {
+  return (await db_name).get(obj_name, key);
+};
+
+export const SetDB = async (db_name, key, val, obj_name) => {
+  return (await db_name).put(obj_name, val, key);
+};
+
+export async function getLocalFile(key) {
+  return (await daopaasDB).get('files', key);
+}
+export async function getLocalReplayFile(key) {
+  return (await daopaasDB).get('replayFiles', key);
+}
+
+export async function setLocalFile(key, val) {
+  return (await daopaasDB).put('files', val, key);
+}
+
+export async function setLocalReplayFile(key, val) {
+  return (await daopaasDB).put('replayFiles', val, key);
+}
+
+export async function getLocalCRDTs() {
+  // .filter((a) => a.editor.evtType !== 'File')
+  return (await (await daopaasDB).getAll('crdts')).filter(
+    (a) => a?.editor?.evtType !== 'File',
+  );
+}
+
+export async function setLocalMedia(key, val) {
+  return (await daopaasDB).put('media', val, key);
+}
+
+export async function getLocalMedia() {
+  return (await daopaasDB).getAll('media');
+}
+
+// export async function getEditorOTLength(key) {
+//   return (await dbPromise).get('editor', key);
+// }
+
+// export async function setEditorOT(key, val) {
+//   return (await dbPromise).put('editor', val, key);
+// }
+
+// export async function delEditorOT(key) {
+//   return (await dbPromise).delete('editor', key);
+// }
+
+// export async function clearEditorOT() {
+//   return (await dbPromise).clear('editor');
+// }
+
+// export async function keys() {
+//   return (await dbPromise).getAllKeys('keyval');
+// }
+
+// export { IDB };
+
+// export interface MyDB extends DBSchema {
+//   'favourite-number': {
+//     key: string;
+//     value: number;
+//   };
+//   file: {
+//     key: string;
+//     value: number;
+//   };
+//   editor: {
+//     value: {
+//       file: string;
+//       operation: number;
+//     };
+//     key: string;
+//     indexes: {
+//       'by-price': number;
+//       // name: string;
+//     };
+//   };
+// }
+
+// const dbPromise = openDB('oTStore', 1, {
+//   upgrade(db) {
+//     db.createObjectStore('editor');
+//     // db.put()
+//   },
+// });
+
+// export const GenerateDB = async (db_name, length = 1, obj) => {
+//   openDB(db_name, length, {
+//     upgrade(db) {
+//       // callback(db);
+//       db.createObjectStore(obj);
+//     },
+//   });
+// };

package/src/helpers/collections/localStorage.tsx

@@ -0,0 +1,13 @@
+const localStorageSpace = function () {
+  let allStrings = '';
+  for (const key in window.localStorage) {
+    if (window.localStorage.hasOwnProperty(key)) {
+      allStrings += window.localStorage[key];
+    }
+  }
+  return allStrings
+    ? 3 + (allStrings.length * 16) / (8 * 1024) + ' KB'
+    : 'Empty (0 KB)';
+};
+
+export { localStorageSpace };