procon_bypass_man-web 0.1.0

data/src/lib/button_state_diff.test.ts

@@ -0,0 +1,123 @@
+import { Button, buttons } from "../types/button";
+import { ButtonInLayer, ButtonsInLayer, Layers, ButtonsSettingType } from "../types/buttons_setting_type";
+import { ButtonStateDiff } from "./button_state_diff";
+
+const makeLayer = () => {
+  const defaultLayer = buttons.reduce((acc, item) => { acc[item] = { open: false }; return acc; }, {} as ButtonsInLayer);
+  const upLayer =  Object.assign({}, defaultLayer);
+  const downLayer = Object.assign({}, defaultLayer);
+  const leftLayer = Object.assign({}, defaultLayer);
+  const rightLayer = Object.assign({}, defaultLayer);
+  return {
+    prefix_keys_for_changing_layer: [] as Array<Button>,
+    layers: {
+      up: Object.assign({}, upLayer),
+      down: Object.assign({}, downLayer),
+      left: Object.assign({}, leftLayer),
+      right: Object.assign({}, rightLayer),
+      installed_macros: {},
+      installed_modes: {},
+    }
+  };
+};
+
+describe('全部ブランクの時', () => {
+  it('[]を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([])
+  })
+})
+
+describe('keyで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.prefix_keys_for_changing_layer = ["a"];
+    after.prefix_keys_for_changing_layer = ["y", "x"];
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual(["key prefixは a => y,x になります"])
+  })
+})
+
+describe('layersで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.prefix_keys_for_changing_layer = ["a"];
+    after.prefix_keys_for_changing_layer = ["a"];
+    before.layers.up.a = { flip: { if_pressed: ["y"], enable: true }, open: true }
+    before.layers.down.a = { flip: { if_pressed: ["y"], enable: true }, open: true }
+    after.layers.up.a = { flip: { if_pressed: ["a"], enable: false }, open: true }
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([
+      "layer up の a を変更しました",
+      "layer down の a を変更しました",
+    ])
+  })
+})
+
+describe('installed_macrosで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.layers.installed_macros = { a: true }
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([
+      "インストール可能なマクロを変更しました"
+    ])
+  })
+})
+
+describe('layer.x.macroで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.layers.up.macro = { a: [] }
+    after.layers.up.macro = { a: ["b"] }
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([
+      "layer up の マクロ を変更しました"
+    ])
+  })
+})
+
+describe('installed_modesで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.layers.installed_modes = { b: true }
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([
+      "インストール可能なモードを変更しました"
+    ])
+  })
+})
+
+describe('layer.x.modeで差分がある時', () => {
+  it('値を返す', () => {
+    const before = Object.assign({}, makeLayer());
+    const after = Object.assign({}, makeLayer());
+
+    before.layers.up.mode = {}
+    after.layers.up.mode = { a: true }
+
+    const actual = ButtonStateDiff({ before: before, after: after })
+    expect(actual).toStrictEqual([
+      "layer up の モード を変更しました"
+    ])
+  })
+})
+

data/src/lib/button_state_diff.ts

@@ -0,0 +1,63 @@
+import { Button, buttons } from "../types/button";
+import { ButtonInLayer, ButtonsInLayer, Layers, ButtonsSettingType, Macro, ModeTable } from "../types/buttons_setting_type";
+import { LayerKey, layerKeys } from "../types/layer_key";
+import { diff } from 'deep-object-diff';
+
+type Props = {
+  before: ButtonsSettingType;
+  after: ButtonsSettingType;
+};
+
+export const ButtonStateDiff = ({ before, after }: Props): Array<string> => {
+  const changes = [] as Array<string>;
+
+  if(!before || !after || !before.layers) { return changes; };
+
+  if(before.layers.installed_macros && after.layers.installed_macros) {
+    const installedMacrosDiffResult = diff(before.layers.installed_macros, after.layers.installed_macros);
+    if(Object.keys(installedMacrosDiffResult || []).length > 0) {
+      changes.push("インストール可能なマクロを変更しました")
+    }
+  }
+
+  if(before.layers.installed_modes && after.layers.installed_modes) {
+    const installedModesDiffResult = diff(before.layers.installed_modes, after.layers.installed_modes);
+    if(Object.keys(installedModesDiffResult || []).length > 0) {
+      changes.push("インストール可能なモードを変更しました")
+    }
+  }
+
+  if(before.prefix_keys_for_changing_layer && after.prefix_keys_for_changing_layer) {
+    if(before.prefix_keys_for_changing_layer.toString() === after.prefix_keys_for_changing_layer.toString()) {
+      // no-op
+    } else {
+      changes.push(`key prefixは ${before.prefix_keys_for_changing_layer} => ${after.prefix_keys_for_changing_layer} になります`)
+    }
+  }
+
+  layerKeys.forEach((layerKey) => {
+    const beforeMacro = before.layers[layerKey].macro || {} as Macro
+    const afterMacro = after.layers[layerKey].macro || {} as Macro
+    const macroDiffResult = diff(beforeMacro, afterMacro);
+    if(Object.keys(macroDiffResult || []).length > 0) {
+      changes.push(`layer ${layerKey} の マクロ を変更しました`)
+    }
+
+    const beforeMode = before.layers[layerKey].mode || {} as ModeTable
+    const afterMode = after.layers[layerKey].mode || {} as ModeTable
+    const modeDiffResult = diff(beforeMode, afterMode);
+    if(Object.keys(modeDiffResult || []).length > 0) {
+      changes.push(`layer ${layerKey} の モード を変更しました`)
+    }
+
+    buttons.forEach((b) => {
+      // どの項目が何に変化したかを出力したかったがめんどくさすぎたのでやめた
+      const diffResult = diff(before.layers[layerKey as LayerKey][b], after.layers[layerKey as LayerKey][b]);
+      if(Object.keys(diffResult || []).length > 0) {
+        changes.push(`layer ${layerKey} の ${b} を変更しました`)
+      }
+    })
+  })
+
+  return changes;
+}

data/src/lib/buttons_setting_converter.test.ts

@@ -0,0 +1,185 @@
+import { ButtonsSettingConverter } from "./buttons_setting_converter";
+import { Button, buttons } from "../types/button";
+import { ButtonsInLayer } from "../types/buttons_setting_type";
+import yaml from "js-yaml";
+import _ from 'lodash';
+
+describe('値があるとき', () => {
+  const prefixKeys = ["y", "l"] as Array<Button>;
+  const defaultLayer = buttons.reduce((acc, item) => { acc[item] = { open: false }; return acc; }, {} as ButtonsInLayer);
+  const upLayer =  _.cloneDeep(defaultLayer);
+  const downLayer = _.cloneDeep(defaultLayer);
+  const leftLayer = _.cloneDeep(defaultLayer);
+  const rightLayer = _.cloneDeep(defaultLayer);
+  upLayer.a = { flip: { if_pressed: [], enable: true, force_neutral: ["y"] }, open: true }
+  upLayer.b = { flip: { if_pressed: ["a"], enable: true, force_neutral: ["y"] }, open: true }
+  upLayer.x = { flip: { if_pressed: ["a"], enable: false, force_neutral: ["y"] }, open: true }
+  upLayer.y = { flip: { if_pressed: [], enable: false, force_neutral: [] }, open: true }
+  downLayer.a = { flip: { if_pressed: ["a", "b"], enable: true, force_neutral: ["y", "x"] }, open: true }
+  leftLayer.a = { remap: { to: ["b", "y"] }, open: true }
+  const layers = {
+    up: upLayer,
+    down: downLayer,
+    left: leftLayer,
+    right: rightLayer,
+  };
+
+  it('validなyamlであること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    yaml.load(actual)
+  })
+
+  it('定義が出力されること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    const expected = `version: 1.0
+setting: |-
+
+
+  prefix_keys_for_changing_layer %i(y l)
+
+  layer :up do
+    flip :a, force_neutral: %i(y)
+    flip :b, if_pressed: %i(a), force_neutral: %i(y)
+
+  end
+  layer :right do
+
+  end
+  layer :down do
+    flip :a, if_pressed: %i(a b), force_neutral: %i(y x)
+
+  end
+  layer :left do
+    remap :a, to: %i(b y)
+
+  end`;
+    expect(actual).toBe(expected);
+  })
+})
+
+describe('macroがあるとき', () => {
+  const prefixKeys = ["y", "l"] as Array<Button>;
+  const defaultLayer = buttons.reduce((acc, item) => { acc[item] = { open: false }; return acc; }, {} as ButtonsInLayer);
+  const upLayer =  _.cloneDeep(defaultLayer);
+  upLayer.macro = { "ProconBypassMan::Splatoon2::Macro::FastReturn": ["y", "l"] }
+  const downLayer = _.cloneDeep(defaultLayer);
+  const leftLayer = _.cloneDeep(defaultLayer);
+  const rightLayer = _.cloneDeep(defaultLayer);
+  const layers = {
+    up: upLayer,
+    down: downLayer,
+    left: leftLayer,
+    right: rightLayer,
+    installed_macros: {
+      "ProconBypassMan::Splatoon2::Macro::FastReturn": true,
+      "ProconBypassMan::Sumabura::Macro::Foo": true,
+      "HOGE": false,
+    }
+  };
+
+  it('installed_macroを出力すること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    const expected = `version: 1.0
+setting: |-
+  install_macro_plugin ProconBypassMan::Splatoon2::Macro::FastReturn
+  install_macro_plugin ProconBypassMan::Sumabura::Macro::Foo
+
+  prefix_keys_for_changing_layer %i(y l)
+
+  layer :up do
+    macro ProconBypassMan::Splatoon2::Macro::FastReturn, if_pressed: %i(y l)
+  end
+  layer :right do
+
+  end
+  layer :down do
+
+  end
+  layer :left do
+
+  end`;
+    expect(actual).toBe(expected);
+  })
+})
+
+describe('modeがあるとき', () => {
+  const prefixKeys = ["y", "l"] as Array<Button>;
+  const defaultLayer = buttons.reduce((acc, item) => { acc[item] = { open: false }; return acc; }, {} as ButtonsInLayer);
+  const upLayer =  _.cloneDeep(defaultLayer);
+  upLayer.mode = { "ProconBypassMan::Splatoon2::Mode::Guruguru": true }
+  const downLayer = _.cloneDeep(defaultLayer);
+  const leftLayer = _.cloneDeep(defaultLayer);
+  const rightLayer = _.cloneDeep(defaultLayer);
+  const layers = {
+    up: upLayer,
+    down: downLayer,
+    left: leftLayer,
+    right: rightLayer,
+    installed_modes: {
+      "ProconBypassMan::Splatoon2::Mode::Guruguru": true,
+      "unknown": false,
+    }
+  };
+
+  it('installed_modeを出力すること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    const expected = `version: 1.0
+setting: |-
+
+  install_mode_plugin ProconBypassMan::Splatoon2::Mode::Guruguru
+  prefix_keys_for_changing_layer %i(y l)
+
+  layer :up, mode: ProconBypassMan::Splatoon2::Mode::Guruguru do
+
+  end
+  layer :right do
+
+  end
+  layer :down do
+
+  end
+  layer :left do
+
+  end`;
+    expect(actual).toBe(expected);
+  })
+})
+
+describe('全部からのとき', () => {
+  const prefixKeys = ["y", "l"] as Array<Button>;
+  const defaultLayer = buttons.reduce((acc, item) => { acc[item] = { open: false }; return acc; }, {} as ButtonsInLayer);
+  const layers = {
+    up: defaultLayer,
+    down: defaultLayer,
+    left: defaultLayer,
+    right: defaultLayer,
+  };
+
+  it('validなyamlであること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    yaml.load(actual)
+  })
+
+  it('全部空になること', () => {
+    const actual = ButtonsSettingConverter({ prefixKeys: prefixKeys, layers: layers })
+    const expected = `version: 1.0
+setting: |-
+
+
+  prefix_keys_for_changing_layer %i(y l)
+
+  layer :up do
+
+  end
+  layer :right do
+
+  end
+  layer :down do
+
+  end
+  layer :left do
+
+  end`;
+    expect(actual).toBe(expected);
+  })
+})

data/src/lib/buttons_setting_converter.ts

@@ -0,0 +1,107 @@
+import { LayerKey, layerKeys } from "../types/layer_key";
+import { Macro, Remap, Flip, Layers, ButtonsInLayer } from "../types/buttons_setting_type";
+import { Button, buttons } from "../types/button";
+
+type Props = {
+  prefixKeys: Array<Button>;
+  layers: Layers;
+};
+export const ButtonsSettingConverter = ({ prefixKeys, layers }: Props) => {
+  const layerBlock = (layerKey: LayerKey) => {
+    const modeTable = layers[layerKey].mode || {}
+    const currentMode = Object.keys(modeTable).toString();
+    if(currentMode === "disable" || currentMode === '') {
+      return `layer :${layerKey} do`;
+    } else {
+      const modeOption = `, mode: ${currentMode}`
+      return `layer :${layerKey}${modeOption} do`;
+    }
+  }
+  type defineButtonMethodProps = {
+    layer: ButtonsInLayer;
+    button: Button;
+  };
+  const buttons_with_macro = buttons
+  const createButtonMethod = ({ layer , button }: defineButtonMethodProps) => {
+    const flip = layer[button].flip;
+    const remap = layer[button].remap;
+    if(flip && flip.enable) {
+      if(!flip.if_pressed) { return }
+      if(flip.if_pressed.length === 0) {
+        return `flip :${button}${(flip.force_neutral || "") && `, force_neutral: %i(${flip.force_neutral?.join(" ")})`}`;
+      } else {
+        // ex) flip :a
+        //     flip :a, if_pressed: [:b]
+        return `flip :${button}${(flip.if_pressed || "") && `, if_pressed: %i(${flip.if_pressed?.join(" ")})`}${(flip.force_neutral || "") && `, force_neutral: %i(${flip.force_neutral?.join(" ")})`}`;
+      }
+    } else { // flipとremapは共存できないのでelseにする
+      if(remap) {
+        return `remap :${button}${(remap.to || "") && `, to: %i(${remap.to.join(" ")})`}`;
+      }
+    }
+    return null;
+  }
+
+  const layerBlockIndent = "    ";
+  const topLevelIndent = "  ";
+  if(!layers.installed_macros) {  layers.installed_macros = {} };
+  if(!layers.installed_modes) {  layers.installed_modes = {} };
+  if(!layers.up.macro) { layers.up.macro = {} };
+  if(!layers.down.macro) { layers.down.macro = {} };
+  if(!layers.right.macro) { layers.right.macro = {} };
+  if(!layers.left.macro) { layers.left.macro = {} };
+  const installedMacroNames = Object.entries(layers.installed_macros).filter((k, i) => k[1]).map(v => v[0]);
+  const installedModeNames = Object.entries(layers.installed_modes).filter((k, i) => k[1]).map(v => v[0]);
+
+  const expandMacroInLayer = (macro: Macro) => {
+    return Object.entries(macro).map((m) => {
+      const name = m[0] as string;
+      const ifPressed = m[1] as Array<Button>;
+      return `${layerBlockIndent}macro ${name}, if_pressed: %i(${ifPressed.join(" ")})` }
+    )
+  };
+
+  return(
+`version: 1.0
+setting: |-
+${installedMacroNames.map((name) => `${topLevelIndent}install_macro_plugin ${name}`).join("\n")}
+${installedModeNames.map((name) => `${topLevelIndent}install_mode_plugin ${name}`).join("\n")}
+  prefix_keys_for_changing_layer %i(${prefixKeys.join(" ")})
+
+  ${
+    buttons.reduce((a, b) => {
+      const m = createButtonMethod({ layer: layers.up, button: b })
+      if(m) { a = a + `\n${layerBlockIndent}` + m }
+      return a;
+    }, layerBlock("up"))
+  }
+${expandMacroInLayer(layers.up.macro)}
+  end
+  ${
+    buttons.reduce((a, b) => {
+      const m = createButtonMethod({ layer: layers.right, button: b })
+      if(m) { a = a + `\n${layerBlockIndent}` + m }
+      return a;
+    }, layerBlock("right"))
+  }
+${expandMacroInLayer(layers.down.macro)}
+  end
+  ${
+    buttons.reduce((a, b) => {
+      const m = createButtonMethod({ layer: layers.down, button: b })
+      if(m) { a = a + `\n${layerBlockIndent}` + m }
+      return a;
+    }, layerBlock("down"))
+  }
+${expandMacroInLayer(layers.down.macro)}
+  end
+  ${
+    buttons.reduce((a, b) => {
+      const m = createButtonMethod({ layer: layers.left, button: b })
+      if(m) { a = a + `\n${layerBlockIndent}` + m }
+      return a;
+    }, layerBlock("left"))
+  }
+${expandMacroInLayer(layers.left.macro)}
+  end`)
+}