@bemedev/decompose 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 chlbri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# Package NPM

package/lib/constants/strings.d.ts

@@ -0,0 +1 @@
+export declare const DELIMITER: "-{/./:}-";

package/lib/decompose.d.ts

@@ -0,0 +1,3 @@
+import { StateValue } from 'xstate';
+import { StateMatching } from './types';
+export declare function decompose<T extends StateValue>(val: T, sorter?: (a: string, b: string) => number): readonly StateMatching<T>[];

package/lib/index.cjs

@@ -0,0 +1,2 @@
+function e(e){return void 0===e&&(e="-{/./:}-"),function(t,r){return t.split(e).length-r.split(e).length||t.localeCompare(r)}}function t(e,r){void 0===r&&(r="");var n=r?r+"-{/./:}-":"",o=[];if(""!==r&&o.push(r),"string"==typeof e)o.push(""+n+e);else{var p=Object.keys(e);o.push.apply(o,p.map(function(r){return t(e[r],""+n+r)}).flat())}return o}exports.decompose=function(r,n){var o=t(r,"");o.sort(null!=n?n:e("-{/./:}-"));var p=new RegExp("-{/./:}-","g"),u=o.map(function(e){return e.replace(p,".")});return Object.freeze(u)},exports.sortMap=e;
+//# sourceMappingURL=index.cjs.map

package/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/sortMap.ts","../src/constants/strings.ts","../src/decompose.ts"],"sourcesContent":["import { DELIMITER } from './constants/strings';\n\nexport function sortMap(\n  delimiter: string = DELIMITER,\n): ((a: string, b: string) => number) | undefined {\n  return (a, b) => {\n    return (\n      a.split(delimiter).length - b.split(delimiter).length ||\n      a.localeCompare(b)\n    );\n  };\n}\n","export const DELIMITER = '-{/./:}-' as const;\n","import { StateValue } from 'xstate';\nimport { DELIMITER } from './constants/strings';\nimport { sortMap } from './sortMap';\nimport { StateMatching } from './types';\n\nfunction ddecompose(val: StateValue, prev = '') {\n  const _prev = prev ? prev + DELIMITER : '';\n  const output: string[] = [];\n  prev !== '' && output.push(prev);\n  if (typeof val === 'string') {\n    output.push(`${_prev}${val}`);\n  } else {\n    const keys = Object.keys(val);\n    output.push(\n      ...keys.map(key => ddecompose(val[key], `${_prev}${key}`)).flat(),\n    );\n  }\n\n  return output;\n}\n\nexport function decompose<T extends StateValue>(\n  val: T,\n  sorter?: (a: string, b: string) => number,\n): readonly StateMatching<T>[] {\n  const first = ddecompose(val, '');\n  first.sort(sorter ?? sortMap(DELIMITER));\n  const regex = new RegExp(DELIMITER, 'g');\n  const output = first.map(value => value.replace(regex, '.'));\n\n  return Object.freeze(output) as StateMatching<T>[];\n}\n"],"names":["sortMap","delimiter","a","b","split","length","localeCompare","ddecompose","val","prev","_prev","output","push","Object","keys","map","key","flat","sorter","first","sort","value","replace","regex","freeze"],"mappings":"AAEgBA,SAAAA,EACdC,GAEA,YAF6B,IAA7BA,IAAAA,ECHuB,YDKhB,SAACC,EAAGC,GACT,OACED,EAAEE,MAAMH,GAAWI,OAASF,EAAEC,MAAMH,GAAWI,QAC/CH,EAAEI,cAAcH,EAEnB,CACF,CEND,SAAAI,EAAoBC,EAAiBC,YAAAA,IAAAA,EAAO,IAC1C,IAAWC,EAAGD,EAAOA,EDNE,WCMiB,KACf,GAEzB,GADS,KAATA,GAAeE,EAAOC,KAAKH,GACR,mBACjBE,EAAOC,KAAP,GAAeF,EAAQF,OAClB,CACL,MAAaK,OAAOC,KAAKN,GACzBG,EAAOC,WAAPD,EACKG,EAAKC,IAAI,SAAAC,GAAOT,OAAAA,EAAWC,EAAIQ,GAAL,GAAcN,EAAQM,EAApC,GAA4CC,OAE9D,CAED,OAAON,CACR,mBAEe,SACdH,EACAU,GAEA,MAAcX,EAAWC,EAAK,IAC9BW,EAAMC,KAAN,MAAWF,EAAAA,EAAUlB,ED1BE,aC2BvB,MAAc,WD3BS,WC2Ba,KAC9BW,EAASQ,EAAMJ,IAAI,SAAAM,GAASA,OAAAA,EAAMC,QAAQC,EAAO,IAAzB,GAE9B,OAAOV,OAAOW,OAAOb,EACtB"}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './decompose';
+export * from './sortMap';
+export * from './types';

package/lib/index.esm.js

@@ -0,0 +1,2 @@
+function e(e){return void 0===e&&(e="-{/./:}-"),function(n,t){return n.split(e).length-t.split(e).length||n.localeCompare(t)}}function n(e,t){void 0===t&&(t="");var r=t?t+"-{/./:}-":"",u=[];if(""!==t&&u.push(t),"string"==typeof e)u.push(""+r+e);else{var p=Object.keys(e);u.push.apply(u,p.map(function(t){return n(e[t],""+r+t)}).flat())}return u}function t(t,r){var u=n(t,"");u.sort(null!=r?r:e("-{/./:}-"));var p=new RegExp("-{/./:}-","g"),o=u.map(function(e){return e.replace(p,".")});return Object.freeze(o)}export{t as decompose,e as sortMap};
+//# sourceMappingURL=index.esm.js.map

package/lib/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../src/sortMap.ts","../src/constants/strings.ts","../src/decompose.ts"],"sourcesContent":["import { DELIMITER } from './constants/strings';\n\nexport function sortMap(\n  delimiter: string = DELIMITER,\n): ((a: string, b: string) => number) | undefined {\n  return (a, b) => {\n    return (\n      a.split(delimiter).length - b.split(delimiter).length ||\n      a.localeCompare(b)\n    );\n  };\n}\n","export const DELIMITER = '-{/./:}-' as const;\n","import { StateValue } from 'xstate';\nimport { DELIMITER } from './constants/strings';\nimport { sortMap } from './sortMap';\nimport { StateMatching } from './types';\n\nfunction ddecompose(val: StateValue, prev = '') {\n  const _prev = prev ? prev + DELIMITER : '';\n  const output: string[] = [];\n  prev !== '' && output.push(prev);\n  if (typeof val === 'string') {\n    output.push(`${_prev}${val}`);\n  } else {\n    const keys = Object.keys(val);\n    output.push(\n      ...keys.map(key => ddecompose(val[key], `${_prev}${key}`)).flat(),\n    );\n  }\n\n  return output;\n}\n\nexport function decompose<T extends StateValue>(\n  val: T,\n  sorter?: (a: string, b: string) => number,\n): readonly StateMatching<T>[] {\n  const first = ddecompose(val, '');\n  first.sort(sorter ?? sortMap(DELIMITER));\n  const regex = new RegExp(DELIMITER, 'g');\n  const output = first.map(value => value.replace(regex, '.'));\n\n  return Object.freeze(output) as StateMatching<T>[];\n}\n"],"names":["sortMap","delimiter","a","b","split","length","localeCompare","ddecompose","val","prev","_prev","output","push","Object","keys","map","key","flat","decompose","sorter","first","sort","value","replace","regex","freeze"],"mappings":"AAEgBA,SAAAA,EACdC,GAEA,YAF6B,IAA7BA,IAAAA,ECHuB,YDKhB,SAACC,EAAGC,GACT,OACED,EAAEE,MAAMH,GAAWI,OAASF,EAAEC,MAAMH,GAAWI,QAC/CH,EAAEI,cAAcH,EAEnB,CACF,CEND,SAAAI,EAAoBC,EAAiBC,YAAAA,IAAAA,EAAO,IAC1C,IAAWC,EAAGD,EAAOA,EDNE,WCMiB,KACf,GAEzB,GADS,KAATA,GAAeE,EAAOC,KAAKH,GACR,mBACjBE,EAAOC,KAAP,GAAeF,EAAQF,OAClB,CACL,MAAaK,OAAOC,KAAKN,GACzBG,EAAOC,WAAPD,EACKG,EAAKC,IAAI,SAAAC,GAAOT,OAAAA,EAAWC,EAAIQ,GAAL,GAAcN,EAAQM,EAApC,GAA4CC,OAE9D,CAED,OAAON,CACR,CAEe,SAAAO,EACdV,EACAW,GAEA,MAAcZ,EAAWC,EAAK,IAC9BY,EAAMC,KAAN,MAAWF,EAAAA,EAAUnB,ED1BE,aC2BvB,MAAc,WD3BS,WC2Ba,KAC9BW,EAASS,EAAML,IAAI,SAAAO,GAASA,OAAAA,EAAMC,QAAQC,EAAO,IAAzB,GAE9B,OAAOX,OAAOY,OAAOd,EACtB"}

package/lib/index.modern.js

@@ -0,0 +1,2 @@
+function e(e="-{/./:}-"){return(t,n)=>t.split(e).length-n.split(e).length||t.localeCompare(n)}function t(e,n=""){const s=n?n+"-{/./:}-":"",o=[];if(""!==n&&o.push(n),"string"==typeof e)o.push(`${s}${e}`);else{const n=Object.keys(e);o.push(...n.map(n=>t(e[n],`${s}${n}`)).flat())}return o}function n(n,s){const o=t(n,"");o.sort(null!=s?s:e("-{/./:}-"));const p=new RegExp("-{/./:}-","g"),r=o.map(e=>e.replace(p,"."));return Object.freeze(r)}export{n as decompose,e as sortMap};
+//# sourceMappingURL=index.modern.js.map

package/lib/index.modern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.modern.js","sources":["../src/sortMap.ts","../src/constants/strings.ts","../src/decompose.ts"],"sourcesContent":["import { DELIMITER } from './constants/strings';\n\nexport function sortMap(\n  delimiter: string = DELIMITER,\n): ((a: string, b: string) => number) | undefined {\n  return (a, b) => {\n    return (\n      a.split(delimiter).length - b.split(delimiter).length ||\n      a.localeCompare(b)\n    );\n  };\n}\n","export const DELIMITER = '-{/./:}-' as const;\n","import { StateValue } from 'xstate';\nimport { DELIMITER } from './constants/strings';\nimport { sortMap } from './sortMap';\nimport { StateMatching } from './types';\n\nfunction ddecompose(val: StateValue, prev = '') {\n  const _prev = prev ? prev + DELIMITER : '';\n  const output: string[] = [];\n  prev !== '' && output.push(prev);\n  if (typeof val === 'string') {\n    output.push(`${_prev}${val}`);\n  } else {\n    const keys = Object.keys(val);\n    output.push(\n      ...keys.map(key => ddecompose(val[key], `${_prev}${key}`)).flat(),\n    );\n  }\n\n  return output;\n}\n\nexport function decompose<T extends StateValue>(\n  val: T,\n  sorter?: (a: string, b: string) => number,\n): readonly StateMatching<T>[] {\n  const first = ddecompose(val, '');\n  first.sort(sorter ?? sortMap(DELIMITER));\n  const regex = new RegExp(DELIMITER, 'g');\n  const output = first.map(value => value.replace(regex, '.'));\n\n  return Object.freeze(output) as StateMatching<T>[];\n}\n"],"names":["delimiter","a","b","split","length","localeCompare","ddecompose","val","prev","_prev","output","push","Object","keys","map","key","flat","decompose","sorter","first","sort","sortMap","RegExp","value","replace","regex","freeze"],"mappings":"AAEgB,WACdA,ECHuB,YDKvB,MAAO,CAACC,EAAGC,MAELC,MAAMH,GAAWI,OAASF,EAAEC,MAAMH,GAAWI,QAC/CH,EAAEI,cAAcH,EAGrB,CEND,SAASI,EAAWC,EAAiBC,EAAO,IAC1C,MAAWC,EAAGD,EAAOA,EDNE,WCMiB,KACf,GAEzB,GADS,KAATA,GAAeE,EAAOC,KAAKH,GACR,mBACjBE,EAAOC,KAAK,GAAGF,IAAQF,SAClB,CACL,QAAaK,OAAOC,KAAKN,GACzBG,EAAOC,QACFE,EAAKC,IAAIC,GAAOT,EAAWC,EAAIQ,GAAS,GAAAN,IAAQM,MAAQC,OAE9D,CAED,OAAON,CACR,CAEe,SAAAO,EACdV,EACAW,GAEA,QAAcZ,EAAWC,EAAK,IAC9BY,EAAMC,KAAN,MAAWF,EAAAA,EAAUG,ED1BE,aC2BvB,QAAc,IAAAC,OD3BS,WC2Ba,OACrBH,EAAML,IAAIS,GAASA,EAAMC,QAAQC,EAAO,MAEvD,OAAOb,OAAOc,OAAOhB,EACtB"}

package/lib/index.umd.js

@@ -0,0 +1,2 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e||self).decompose={})}(this,function(e){var n="-{/./:}-";function t(e){return void 0===e&&(e=n),function(n,t){return n.split(e).length-t.split(e).length||n.localeCompare(t)}}function o(e,t){void 0===t&&(t="");var r=t?t+n:"",f=[];if(""!==t&&f.push(t),"string"==typeof e)f.push(""+r+e);else{var i=Object.keys(e);f.push.apply(f,i.map(function(n){return o(e[n],""+r+n)}).flat())}return f}e.decompose=function(e,r){var f=o(e,"");f.sort(null!=r?r:t(n));var i=new RegExp(n,"g"),p=f.map(function(e){return e.replace(i,".")});return Object.freeze(p)},e.sortMap=t});
+//# sourceMappingURL=index.umd.js.map

package/lib/index.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.js","sources":["../src/constants/strings.ts","../src/sortMap.ts","../src/decompose.ts"],"sourcesContent":["export const DELIMITER = '-{/./:}-' as const;\n","import { DELIMITER } from './constants/strings';\n\nexport function sortMap(\n  delimiter: string = DELIMITER,\n): ((a: string, b: string) => number) | undefined {\n  return (a, b) => {\n    return (\n      a.split(delimiter).length - b.split(delimiter).length ||\n      a.localeCompare(b)\n    );\n  };\n}\n","import { StateValue } from 'xstate';\nimport { DELIMITER } from './constants/strings';\nimport { sortMap } from './sortMap';\nimport { StateMatching } from './types';\n\nfunction ddecompose(val: StateValue, prev = '') {\n  const _prev = prev ? prev + DELIMITER : '';\n  const output: string[] = [];\n  prev !== '' && output.push(prev);\n  if (typeof val === 'string') {\n    output.push(`${_prev}${val}`);\n  } else {\n    const keys = Object.keys(val);\n    output.push(\n      ...keys.map(key => ddecompose(val[key], `${_prev}${key}`)).flat(),\n    );\n  }\n\n  return output;\n}\n\nexport function decompose<T extends StateValue>(\n  val: T,\n  sorter?: (a: string, b: string) => number,\n): readonly StateMatching<T>[] {\n  const first = ddecompose(val, '');\n  first.sort(sorter ?? sortMap(DELIMITER));\n  const regex = new RegExp(DELIMITER, 'g');\n  const output = first.map(value => value.replace(regex, '.'));\n\n  return Object.freeze(output) as StateMatching<T>[];\n}\n"],"names":["DELIMITER","sortMap","delimiter","a","b","split","length","localeCompare","ddecompose","val","prev","_prev","output","push","Object","keys","map","key","flat","sorter","first","sort","value","replace","regex","freeze"],"mappings":"mOAAO,IAAeA,EAAG,WCETC,SAAAA,EACdC,GAEA,YAF6B,IAA7BA,IAAAA,EAAoBF,GAEb,SAACG,EAAGC,GACT,OACED,EAAEE,MAAMH,GAAWI,OAASF,EAAEC,MAAMH,GAAWI,QAC/CH,EAAEI,cAAcH,EAEnB,CACF,CCND,SAAAI,EAAoBC,EAAiBC,YAAAA,IAAAA,EAAO,IAC1C,IAAWC,EAAGD,EAAOA,EAAOV,EAAY,KACf,GAEzB,GADS,KAATU,GAAeE,EAAOC,KAAKH,GACR,mBACjBE,EAAOC,KAAP,GAAeF,EAAQF,OAClB,CACL,MAAaK,OAAOC,KAAKN,GACzBG,EAAOC,WAAPD,EACKG,EAAKC,IAAI,SAAAC,GAAOT,OAAAA,EAAWC,EAAIQ,GAAL,GAAcN,EAAQM,EAApC,GAA4CC,OAE9D,CAED,OAAON,CACR,aAEe,SACdH,EACAU,GAEA,MAAcX,EAAWC,EAAK,IAC9BW,EAAMC,KAAN,MAAWF,EAAAA,EAAUlB,EAAQD,IAC7B,MAAc,WAAWA,EAAW,KAC9BY,EAASQ,EAAMJ,IAAI,SAAAM,GAASA,OAAAA,EAAMC,QAAQC,EAAO,IAAzB,GAE9B,OAAOV,OAAOW,OAAOb,EACtB"}

package/lib/sortMap.d.ts

@@ -0,0 +1 @@
+export declare function sortMap(delimiter?: string): ((a: string, b: string) => number) | undefined;

package/lib/types.d.ts

@@ -0,0 +1,14 @@
+import { EventFrom, Interpreter } from 'xstate';
+export declare type StateMatching<T extends Record<string, unknown> | string, Key = keyof T> = T extends Record<string, unknown> ? Key extends string ? T[Key] extends Record<string, unknown> ? `${Key}.${StateMatching<T[Key]>}` | (Key & string) : `${Key}.${T[Key] & string}` | (Key & string) : never : T;
+export declare type LengthOf<T> = T extends ReadonlyArray<unknown> ? T['length'] : number;
+export declare type DecomposeOptions = {
+    delimiter?: string;
+    sorter?: (a: string, b: string) => number;
+};
+declare type _UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type _LastOf<T> = _UnionToIntersection<T extends unknown ? () => T : never> extends () => infer R ? R : never;
+declare type _Push<T extends unknown[], V> = [...T, V];
+declare type _TuplifyUnionBoolean<T> = [T] extends [never] ? true : false;
+export declare type TuplifyUnion<T> = true extends _TuplifyUnionBoolean<T> ? [] : _Push<TuplifyUnion<Exclude<T, _LastOf<T>>>, _LastOf<T>>;
+export declare type OmitEvent<T extends Interpreter<never, never, never, never, never>, K extends EventFrom<T>['type']> = LengthOf<TuplifyUnion<keyof EventFrom<T, K>>> extends 1 ? () => unknown : (data: Omit<EventFrom<T>, 'type'>) => unknown;
+export {};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "umd:main": "lib/index.umd.js",
+  "unpkg": "lib/index.umd.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "exports": {
+    "require": "./lib/index.cjs",
+    "default": "./lib/index.modern.js"
+  },
+  "scripts": {
+    "config": "pnpm install",
+    "start": "pnpm run config && microbundle watch",
+    "build": "rm -rf lib && microbundle",
+    "test": "jest",
+    "remove": "rm -rf lib node_modules pnpm-lock.yaml",
+    "clean": "pnpm run remove && pnpm run config",
+    "test-watch": "pnpm test -- --watch",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "eslint": "eslint \"{src/**/*,App}.{ts,tsx}\"",
+    "lint": "pnpm run prettier && pnpm run eslint --fix",
+    "lint-watch": "onchange --await-write-finish 5500 \"**/*\" -- pnpm run lint",
+    "postpublish": "git fetch & git pull",
+    "prepublishOnly": "pnpm run build && pnpm run lint"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "prettier --write \"**/**.{ts,tsx,json,js,jsx,yml}\"",
+      "post-commit": "a"
+    }
+  },
+  "name": "@bemedev/decompose",
+  "author": "chlbri",
+  "module": "lib/decompose.esm.js",
+  "peerDependencies": {
+    "tslib": "^2.4.0",
+    "typescript": "^4.7.4",
+    "xstate": "^4.33.2"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.2.239",
+    "@swc/jest": "^0.2.22",
+    "@types/jest": "^28.1.7",
+    "@types/node": "^18.7.6",
+    "@typescript-eslint/eslint-plugin": "^5.33.1",
+    "@typescript-eslint/parser": "^5.33.1",
+    "eslint": "^8.22.0",
+    "husky": "^8.0.1",
+    "jest": "27.5.0",
+    "jest-extended": "^3.0.2",
+    "microbundle": "^0.15.1",
+    "onchange": "^7.1.0",
+    "prettier": "^2.7.1",
+    "size-limit": "^8.0.1",
+    "typescript": "^4.7.4",
+    "xstate": "^4.33.2"
+  },
+  "wallaby": {
+    "slowTestThreshold": 200
+  }
+}

package/src/constants/strings.ts

@@ -0,0 +1 @@
+export const DELIMITER = '-{/./:}-' as const;

package/src/decompose.test.ts

@@ -0,0 +1,71 @@
+import { decompose } from './decompose';
+
+it('String', () => {
+  expect(decompose('Hello World')).toEqual(['Hello World']);
+});
+
+it('Simple object', () => {
+  const obj = {
+    a: 'Hello',
+    b: 'World',
+  };
+  expect(decompose(obj)).toEqual(['a', 'b', 'a.Hello', 'b.World']);
+});
+
+it('Complex object', () => {
+  const obj = {
+    a: 'Hello',
+    b: 'World',
+    c: {
+      d: 'Hello',
+      e: {
+        f: 'World',
+        g: 'Again',
+      },
+    },
+  };
+  expect(decompose(obj)).toEqual([
+    'a',
+    'b',
+    'c',
+    'a.Hello',
+    'b.World',
+    'c.d',
+    'c.e',
+    'c.d.Hello',
+    'c.e.f',
+    'c.e.g',
+    'c.e.f.World',
+    'c.e.g.Again',
+  ]);
+});
+
+it('Complex object with custom order', () => {
+  const obj = {
+    a: 'Hello',
+    b: 'World',
+    c: {
+      d: 'Hello',
+      e: {
+        f: 'World',
+        g: 'Again',
+      },
+    },
+  };
+
+  const actual = decompose(obj, (a, b) => a.localeCompare(b));
+  expect(actual).toEqual([
+    'a',
+    'a.Hello',
+    'b',
+    'b.World',
+    'c',
+    'c.d',
+    'c.d.Hello',
+    'c.e',
+    'c.e.f',
+    'c.e.f.World',
+    'c.e.g',
+    'c.e.g.Again',
+  ]);
+});

package/src/decompose.ts

@@ -0,0 +1,32 @@
+import { StateValue } from 'xstate';
+import { DELIMITER } from './constants/strings';
+import { sortMap } from './sortMap';
+import { StateMatching } from './types';
+
+function ddecompose(val: StateValue, prev = '') {
+  const _prev = prev ? prev + DELIMITER : '';
+  const output: string[] = [];
+  prev !== '' && output.push(prev);
+  if (typeof val === 'string') {
+    output.push(`${_prev}${val}`);
+  } else {
+    const keys = Object.keys(val);
+    output.push(
+      ...keys.map(key => ddecompose(val[key], `${_prev}${key}`)).flat(),
+    );
+  }
+
+  return output;
+}
+
+export function decompose<T extends StateValue>(
+  val: T,
+  sorter?: (a: string, b: string) => number,
+): readonly StateMatching<T>[] {
+  const first = ddecompose(val, '');
+  first.sort(sorter ?? sortMap(DELIMITER));
+  const regex = new RegExp(DELIMITER, 'g');
+  const output = first.map(value => value.replace(regex, '.'));
+
+  return Object.freeze(output) as StateMatching<T>[];
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './decompose';
+export * from './sortMap';
+export * from './types';

package/src/sortMap.ts

@@ -0,0 +1,12 @@
+import { DELIMITER } from './constants/strings';
+
+export function sortMap(
+  delimiter: string = DELIMITER,
+): ((a: string, b: string) => number) | undefined {
+  return (a, b) => {
+    return (
+      a.split(delimiter).length - b.split(delimiter).length ||
+      a.localeCompare(b)
+    );
+  };
+}

package/src/types.ts

@@ -0,0 +1,51 @@
+import { EventFrom, Interpreter } from 'xstate';
+
+export type StateMatching<
+  T extends Record<string, unknown> | string,
+  Key = keyof T,
+> = T extends Record<string, unknown>
+  ? Key extends string
+    ? T[Key] extends Record<string, unknown>
+      ? `${Key}.${StateMatching<T[Key]>}` | (Key & string)
+      : `${Key}.${T[Key] & string}` | (Key & string)
+    : never
+  : T;
+
+export type LengthOf<T> = T extends ReadonlyArray<unknown>
+  ? T['length']
+  : number;
+
+export type DecomposeOptions = {
+  delimiter?: string;
+  sorter?: (a: string, b: string) => number;
+};
+
+type _UnionToIntersection<U> = (
+  U extends unknown ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+type _LastOf<T> = _UnionToIntersection<
+  T extends unknown ? () => T : never
+> extends () => infer R
+  ? R
+  : never;
+
+type _Push<T extends unknown[], V> = [...T, V];
+
+type _TuplifyUnionBoolean<T> = [T] extends [never] ? true : false;
+
+// TS4.1+
+export type TuplifyUnion<T> = true extends _TuplifyUnionBoolean<T>
+  ? []
+  : _Push<TuplifyUnion<Exclude<T, _LastOf<T>>>, _LastOf<T>>;
+
+// #endregion
+
+export type OmitEvent<
+  T extends Interpreter<never, never, never, never, never>,
+  K extends EventFrom<T>['type'],
+> = LengthOf<TuplifyUnion<keyof EventFrom<T, K>>> extends 1
+  ? () => unknown
+  : (data: Omit<EventFrom<T>, 'type'>) => unknown;