@bemedev/decompose 0.1.3 → 0.1.5

package/package.json

@@ -1,20 +1,16 @@
 {
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
+  "module": "lib/index.mjs",
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "engines": {
     "node": ">=12"
   },
-  "exports": {
-    "require": "./lib/index.cjs",
-    "default": "./lib/index.modern.js"
-  },
   "scripts": {
     "config": "pnpm install",
     "start": "pnpm run config && microbundle watch",

package/src/constants/strings.ts

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

package/src/decompose.test.ts

@@ -1,72 +0,0 @@
-import { expect, it } from 'vitest';
-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

@@ -1,31 +0,0 @@
-import { DELIMITER } from './constants/strings';
-import { sortMap } from './sortMap';
-import { StateMatching, StateValue } 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

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

package/src/sortMap.ts

@@ -1,12 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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 StateValue = string | StateValueMap;
-
-export interface StateValueMap {
-  [key: string]: StateValue;
-}