@lvce-editor/server 0.0.31 → 0.0.32

package/static/{0e4d46a → 37d2807}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -161,10 +161,17 @@ export const load = async (viewlet, focus = false) => {
     }
     state = ViewletState.ContentLoaded
 
-    await RendererProcess.invoke(
-      /* Viewlet.load */ 'Viewlet.load',
-      /* id */ viewlet.id
-    )
+    if (viewlet.show === false) {
+      await RendererProcess.invoke(
+        /* Viewlet.load */ 'Viewlet.loadModule',
+        /* id */ viewlet.id
+      )
+    } else {
+      await RendererProcess.invoke(
+        /* Viewlet.load */ 'Viewlet.load',
+        /* id */ viewlet.id
+      )
+    }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
       return
@@ -206,6 +213,13 @@ export const load = async (viewlet, focus = false) => {
       } else {
         commands = module.render(viewletState, newState)
       }
+      if (viewlet.show === false) {
+        return [
+          ['Viewlet.create', viewlet.id],
+          ...commands,
+          ['Viewlet.show', viewlet.id],
+        ]
+      }
       await RendererProcess.invoke(
         /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
         /* commands */ commands

package/static/{0e4d46a → 37d2807}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -1,8 +1,7 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
 import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
+import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
 import * as QuickPickEveryThing from '../QuickPick/QuickPickEverything.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
 // TODO send open signal to renderer process before items are ready
 // that way user can already type while items are still loading
@@ -88,7 +87,8 @@ const filterPicks = (state, picks, exclude, value) => {
 const getVisible = (items, minLineY, maxLineY) => {
   const visibleItems = []
   const setSize = items.length
-  for (let i = minLineY; i < maxLineY; i++) {
+  const max = Math.min(items.length, maxLineY)
+  for (let i = minLineY; i < max; i++) {
     const item = items[i]
     visibleItems.push({
       label: item.label,
@@ -182,6 +182,7 @@ export const loadContent = async (state) => {
     minLineY,
     maxLineY,
     value,
+    cursorOffset: value.length,
   }
 }
 
@@ -192,6 +193,7 @@ export const dispose = (state) => {
 }
 
 export const handleBlur = async (state) => {
+  console.log('quickpick blur')
   await Viewlet.closeWidget('QuickPick')
   return state
 }
@@ -239,8 +241,8 @@ export const selectIndex = async (state, index, button = /* left */ 0) => {
   // }
 }
 
-export const selectCurrentIndex = async (state) => {
-  await selectIndex(state, state.focusedIndex)
+export const selectCurrentIndex = (state) => {
+  return selectIndex(state, state.focusedIndex)
 }
 
 // TODO when user types letters -> no need to query provider again -> just filter existing results
@@ -251,12 +253,13 @@ export const handleInput = async (state, value, cursorOffset) => {
   const newPicks = await state.provider.getPicks(value)
   const filterValue = state.provider.getFilterValue(value)
   const items = getFilteredItems(state, newPicks, filterValue)
+  const focusedIndex = items.length === 0 ? -1 : 0
   return {
     ...state,
     value,
     picks: newPicks,
     items,
-    focusedIndex: 0,
+    focusedIndex,
     cursorOffset,
   }
 }
@@ -562,6 +565,13 @@ const renderItems = {
     )
   },
   apply(oldState, newState) {
+    if (newState.items.length === 0) {
+      return [
+        /* Viewlet.send */ 'Viewlet.send',
+        /* id */ 'QuickPick',
+        /* method */ 'showNoResults',
+      ]
+    }
     const visibleItems = getVisible(
       newState.items,
       newState.minLineY,

package/static/37d2807/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.ipc.js

@@ -0,0 +1,11 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletSearch from './ViewletSearch.js'
+
+// prettier-ignore
+export const Commands = {
+  'Search.handleInput': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleInput),
+  'Search.handleClick': Viewlet.wrapViewletCommand('Search', ViewletSearch.handleClick),
+  'Search.setValue': Viewlet.wrapViewletCommand('Search', ViewletSearch.setValue),
+}
+
+export * from './ViewletSearch.js'

package/static/{0e4d46a → 37d2807}/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.js

@@ -1,8 +1,8 @@
-import * as SharedProcess from '../SharedProcess/SharedProcess.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Command from '../Command/Command.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as TextSearch from '../TextSearch/TextSearch.js'
 import * as Workspace from '../Workspace/Workspace.js'
-import * as FindInWorkspace from '../FindInWorkspace/FindInWorkspace.js'
 
 // TODO maybe create should have a container as param like vscode?
 // maybe not?
@@ -39,15 +39,58 @@ export const loadContent = async (state) => {
 
 export const contentLoaded = async () => {}
 
-export const setValue = (state, value) => {
-  state.value = value
+const getStatusMessage = (resultCount, fileResultCount) => {
+  if (resultCount === 0) {
+    return 'No results found'
+  }
+  if (resultCount === 1 && fileResultCount === 1) {
+    return 'Found 1 result in 1 file'
+  }
+  if (fileResultCount === 1) {
+    return `Found ${resultCount} results in 1 file`
+  }
+  return `Found ${resultCount} results in ${fileResultCount} files`
+}
+
+const getResultCounts = (results) => {
+  let resultCount = 0
+  for (const result of results) {
+    resultCount += result.length - 1
+  }
+  return resultCount
+}
+
+// TODO
+export const setValue = async (state, value) => {
+  // state.value = value
   // TODO use Id module
-  state.searchId = Math.random()
-  SharedProcess.send(
-    /* Search.search */ 907771,
-    /* id */ state.id,
-    /* searchId */ state.searchId
-  )
+  // state.searchId = Math.random()
+  // SharedProcess.send(
+  //   /* Search.search */ 907771,
+  //   /* id */ state.id,
+  //   /* searchId */ state.searchId
+  // )
+  // TODO
+  try {
+    const root = Workspace.state.workspacePath
+    const results = await TextSearch.textSearch(root, value)
+    const displayResults = toDisplayResults(results)
+    const resultCount = getResultCounts(results)
+    const fileResultCount = results.length
+    const message = getStatusMessage(resultCount, fileResultCount)
+    return {
+      ...state,
+      value,
+      items: displayResults,
+      message,
+    }
+  } catch (error) {
+    return {
+      ...state,
+      message: `${error}`,
+      value,
+    }
+  }
 }
 
 export const handleResult = async (state, result) => {
@@ -100,30 +143,18 @@ const toDisplayResults = (results) => {
   }
   return displayResults
 }
+// TODO implement virtual list, only send visible items to renderer process
+
+// TODO maybe rename to result.items and result.stats
+// TODO support streaming results
+// TODO support cancellation
+// TODO handle error
+// TODO use command.execute or use module directly?
+// TODO send results to renderer process
+// TODO use virtual list because there might be many results
 
 export const handleInput = async (state, value) => {
-  // TODO support streaming results
-  // TODO support cancellation
-  // TODO handle error
-  // TODO use command.execute or use module directly?
-  const results = await FindInWorkspace.findInWorkspace(value)
-  // TODO send results to renderer process
-  // TODO use virtual list because there might be many results
-  console.log({
-    value,
-    results,
-  })
-
-  // TODO implement virtual list, only send visible items to renderer process
-
-  // TODO maybe rename to result.items and result.stats
-  const displayResults = toDisplayResults(results.results)
-  return {
-    ...state,
-    items: displayResults,
-    fileCount: results.results.length, // TODO this is weird
-    value,
-  }
+  return setValue(state, value)
 }
 
 export const handleClick = async (state, index) => {
@@ -152,7 +183,6 @@ const renderItems = {
     return oldState.items === newState.items
   },
   apply(oldState, newState) {
-    console.log(newState.items)
     return [
       /* viewletSend */ 'Viewlet.send',
       /* id */ 'Search',
@@ -164,4 +194,18 @@ const renderItems = {
   },
 }
 
-export const render = [renderItems]
+const renderMessage = {
+  isEqual(oldState, newState) {
+    return oldState.message === newState.message
+  },
+  apply(oldState, newState) {
+    return [
+      /* viewletSend */ 'Viewlet.send',
+      /* id */ 'Search',
+      /* method */ 'setMessage',
+      /* message */ newState.message,
+    ]
+  },
+}
+
+export const render = [renderItems, renderMessage]

package/static/{0e4d46a → 37d2807}/packages/renderer-worker/src/parts/ViewletStates/ViewletStates.js

@@ -15,6 +15,10 @@ export const getInstance = (key) => {
   return state.instances[key]
 }
 
+export const hasInstance = (key) => {
+  return key in state.instances
+}
+
 export const remove = (key) => {
   delete state.instances[key]
 }

package/static/37d2807/static/js/ansi-styles.js

@@ -0,0 +1,148 @@
+import colorConvert from "./color-convert.js";
+function createCommonjsModule(fn, basedir, module) {
+  return module = {
+    path: basedir,
+    exports: {},
+    require: function(path, base) {
+      return commonjsRequire(path, base === void 0 || base === null ? module.path : base);
+    }
+  }, fn(module, module.exports), module.exports;
+}
+function commonjsRequire() {
+  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
+}
+var ansiStyles = createCommonjsModule(function(module) {
+  const wrapAnsi16 = (fn, offset) => function() {
+    const code = fn.apply(colorConvert, arguments);
+    return `[${code + offset}m`;
+  };
+  const wrapAnsi256 = (fn, offset) => function() {
+    const code = fn.apply(colorConvert, arguments);
+    return `[${38 + offset};5;${code}m`;
+  };
+  const wrapAnsi16m = (fn, offset) => function() {
+    const rgb = fn.apply(colorConvert, arguments);
+    return `[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+  };
+  function assembleStyles() {
+    const codes = new Map();
+    const styles = {
+      modifier: {
+        reset: [0, 0],
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        gray: [90, 39],
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        bgBlackBright: [100, 49],
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    styles.color.grey = styles.color.gray;
+    for (const groupName of Object.keys(styles)) {
+      const group = styles[groupName];
+      for (const styleName of Object.keys(group)) {
+        const style = group[styleName];
+        styles[styleName] = {
+          open: `[${style[0]}m`,
+          close: `[${style[1]}m`
+        };
+        group[styleName] = styles[styleName];
+        codes.set(style[0], style[1]);
+      }
+      Object.defineProperty(styles, groupName, {
+        value: group,
+        enumerable: false
+      });
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+    }
+    const ansi2ansi = (n) => n;
+    const rgb2rgb = (r, g, b) => [r, g, b];
+    styles.color.close = "";
+    styles.bgColor.close = "";
+    styles.color.ansi = {
+      ansi: wrapAnsi16(ansi2ansi, 0)
+    };
+    styles.color.ansi256 = {
+      ansi256: wrapAnsi256(ansi2ansi, 0)
+    };
+    styles.color.ansi16m = {
+      rgb: wrapAnsi16m(rgb2rgb, 0)
+    };
+    styles.bgColor.ansi = {
+      ansi: wrapAnsi16(ansi2ansi, 10)
+    };
+    styles.bgColor.ansi256 = {
+      ansi256: wrapAnsi256(ansi2ansi, 10)
+    };
+    styles.bgColor.ansi16m = {
+      rgb: wrapAnsi16m(rgb2rgb, 10)
+    };
+    for (let key of Object.keys(colorConvert)) {
+      if (typeof colorConvert[key] !== "object") {
+        continue;
+      }
+      const suite = colorConvert[key];
+      if (key === "ansi16") {
+        key = "ansi";
+      }
+      if ("ansi16" in suite) {
+        styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+        styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+      }
+      if ("ansi256" in suite) {
+        styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+        styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+      }
+      if ("rgb" in suite) {
+        styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+        styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+      }
+    }
+    return styles;
+  }
+  Object.defineProperty(module, "exports", {
+    enumerable: true,
+    get: assembleStyles
+  });
+});
+export default ansiStyles;