lism-css 0.9.4 → 0.10.1

package/config/helper.test.ts

@@ -2,237 +2,237 @@ import { describe, test, expect } from 'vitest';
 import { objDeepMerge, arrayConvertToSet } from './helper.js';
 
 describe('objDeepMerge', () => {
-	test('基本的なマージが正しく動作する', () => {
-		const origin = { a: 1, b: 2 };
-		const source = { b: 3, c: 4 };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 1, b: 3, c: 4 });
-	});
-
-	test('ネストしたオブジェクトを深くマージする', () => {
-		const origin = { a: { b: 1, c: 2 }, d: 3 };
-		const source = { a: { b: 10, e: 5 }, f: 6 };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: { b: 10, c: 2, e: 5 }, d: 3, f: 6 });
-	});
-
-	test('深くネストしたオブジェクトを正しくマージする', () => {
-		const origin = { a: { b: { c: 1 } } };
-		const source = { a: { b: { d: 2 } } };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: { b: { c: 1, d: 2 } } });
-	});
-
-	test('originが空オブジェクトの場合、sourceをそのまま返す', () => {
-		const origin = {};
-		const source = { a: 1, b: 2 };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 1, b: 2 });
-	});
-
-	test('sourceが空オブジェクトの場合、originをそのまま返す', () => {
-		const origin = { a: 1, b: 2 };
-		const source = {};
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 1, b: 2 });
-	});
-
-	test('originに存在しないキーが追加される', () => {
-		const origin = { a: 1 };
-		const source = { b: 2, c: 3 };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 1, b: 2, c: 3 });
-	});
-
-	test('値がオブジェクトから配列に上書きされる', () => {
-		const origin = { a: { b: 1 } };
-		const source = { a: [1, 2, 3] };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: [1, 2, 3] });
-	});
-
-	test('値が配列からオブジェクトに上書きされる', () => {
-		const origin = { a: [1, 2, 3] };
-		const source = { a: { b: 1 } };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: { b: 1 } });
-	});
-
-	test('値がプリミティブ型の場合、sourceの値で上書きされる', () => {
-		const origin = { a: 1, b: 'hello' };
-		const source = { a: 2, b: 'world' };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 2, b: 'world' });
-	});
-
-	test('originValueがnullまたはundefinedの場合、sourceValueを追加する', () => {
-		const origin = { a: null, b: undefined };
-		const source = { a: 1, b: 2, c: 3 };
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({ a: 1, b: 2, c: 3 });
-	});
-
-	test('元のオブジェクトが変更されないことを確認', () => {
-		const origin = { a: 1, b: { c: 2 } };
-		const source = { b: { d: 3 } };
-		const result = objDeepMerge(origin, source);
-		expect(origin).toEqual({ a: 1, b: { c: 2 } });
-		expect(result).toEqual({ a: 1, b: { c: 2, d: 3 } });
-	});
-
-	test('複雑なネスト構造のマージ', () => {
-		const origin = {
-			level1: {
-				level2: {
-					a: 1,
-					b: 2,
-				},
-				c: 3,
-			},
-			d: 4,
-		};
-		const source = {
-			level1: {
-				level2: {
-					b: 20,
-					e: 5,
-				},
-				f: 6,
-			},
-			g: 7,
-		};
-		const result = objDeepMerge(origin, source);
-		expect(result).toEqual({
-			level1: {
-				level2: {
-					a: 1,
-					b: 20,
-					e: 5,
-				},
-				c: 3,
-				f: 6,
-			},
-			d: 4,
-			g: 7,
-		});
-	});
+  test('基本的なマージが正しく動作する', () => {
+    const origin = { a: 1, b: 2 };
+    const source = { b: 3, c: 4 };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 1, b: 3, c: 4 });
+  });
+
+  test('ネストしたオブジェクトを深くマージする', () => {
+    const origin = { a: { b: 1, c: 2 }, d: 3 };
+    const source = { a: { b: 10, e: 5 }, f: 6 };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: { b: 10, c: 2, e: 5 }, d: 3, f: 6 });
+  });
+
+  test('深くネストしたオブジェクトを正しくマージする', () => {
+    const origin = { a: { b: { c: 1 } } };
+    const source = { a: { b: { d: 2 } } };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: { b: { c: 1, d: 2 } } });
+  });
+
+  test('originが空オブジェクトの場合、sourceをそのまま返す', () => {
+    const origin = {};
+    const source = { a: 1, b: 2 };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test('sourceが空オブジェクトの場合、originをそのまま返す', () => {
+    const origin = { a: 1, b: 2 };
+    const source = {};
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test('originに存在しないキーが追加される', () => {
+    const origin = { a: 1 };
+    const source = { b: 2, c: 3 };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  test('値がオブジェクトから配列に上書きされる', () => {
+    const origin = { a: { b: 1 } };
+    const source = { a: [1, 2, 3] };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: [1, 2, 3] });
+  });
+
+  test('値が配列からオブジェクトに上書きされる', () => {
+    const origin = { a: [1, 2, 3] };
+    const source = { a: { b: 1 } };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: { b: 1 } });
+  });
+
+  test('値がプリミティブ型の場合、sourceの値で上書きされる', () => {
+    const origin = { a: 1, b: 'hello' };
+    const source = { a: 2, b: 'world' };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 2, b: 'world' });
+  });
+
+  test('originValueがnullまたはundefinedの場合、sourceValueを追加する', () => {
+    const origin = { a: null, b: undefined };
+    const source = { a: 1, b: 2, c: 3 };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  test('元のオブジェクトが変更されないことを確認', () => {
+    const origin = { a: 1, b: { c: 2 } };
+    const source = { b: { d: 3 } };
+    const result = objDeepMerge(origin, source);
+    expect(origin).toEqual({ a: 1, b: { c: 2 } });
+    expect(result).toEqual({ a: 1, b: { c: 2, d: 3 } });
+  });
+
+  test('複雑なネスト構造のマージ', () => {
+    const origin = {
+      level1: {
+        level2: {
+          a: 1,
+          b: 2,
+        },
+        c: 3,
+      },
+      d: 4,
+    };
+    const source = {
+      level1: {
+        level2: {
+          b: 20,
+          e: 5,
+        },
+        f: 6,
+      },
+      g: 7,
+    };
+    const result = objDeepMerge(origin, source);
+    expect(result).toEqual({
+      level1: {
+        level2: {
+          a: 1,
+          b: 20,
+          e: 5,
+        },
+        c: 3,
+        f: 6,
+      },
+      d: 4,
+      g: 7,
+    });
+  });
 });
 describe('arrayConvertToSet', () => {
-	test('配列をSetに変換する', () => {
-		const input = [1, 2, 3];
-		const result = arrayConvertToSet(input);
-		expect(result).toBeInstanceOf(Set);
-		expect(result).toEqual(new Set([1, 2, 3]));
-	});
-
-	test('重複した要素を持つ配列をSetに変換する', () => {
-		const input = [1, 2, 2, 3, 3, 3];
-		const result = arrayConvertToSet(input);
-		expect(result).toEqual(new Set([1, 2, 3]));
-	});
-
-	test('オブジェクト内の配列をSetに変換する', () => {
-		const input = { a: [1, 2, 3], b: [4, 5, 6] };
-		const result = arrayConvertToSet(input);
-		expect(result.a).toEqual(new Set([1, 2, 3]));
-		expect(result.b).toEqual(new Set([4, 5, 6]));
-	});
-
-	test('ネストしたオブジェクト内の配列をSetに変換する', () => {
-		const input = {
-			level1: {
-				level2: {
-					arr: [1, 2, 3],
-				},
-			},
-		};
-		const result = arrayConvertToSet(input);
-		expect(result.level1.level2.arr).toEqual(new Set([1, 2, 3]));
-	});
-
-	test('配列とオブジェクトが混在する場合', () => {
-		const input = {
-			a: [1, 2, 3],
-			b: {
-				c: [4, 5, 6],
-				d: 'string',
-			},
-			e: 100,
-		};
-		const result = arrayConvertToSet(input);
-		expect(result.a).toEqual(new Set([1, 2, 3]));
-		expect(result.b.c).toEqual(new Set([4, 5, 6]));
-		expect(result.b.d).toBe('string');
-		expect(result.e).toBe(100);
-	});
-
-	test('プリミティブ値はそのまま返す', () => {
-		expect(arrayConvertToSet(1)).toBe(1);
-		expect(arrayConvertToSet('string')).toBe('string');
-		expect(arrayConvertToSet(true)).toBe(true);
-		expect(arrayConvertToSet(null)).toBe(null);
-		expect(arrayConvertToSet(undefined)).toBe(undefined);
-	});
-
-	test('空配列をSetに変換する', () => {
-		const input: never[] = [];
-		const result = arrayConvertToSet(input);
-		expect(result).toEqual(new Set());
-	});
-
-	test('空オブジェクトをそのまま返す', () => {
-		const input = {};
-		const result = arrayConvertToSet(input);
-		expect(result).toEqual({});
-	});
-
-	test('深くネストしたオブジェクトと配列の変換', () => {
-		const input = {
-			a: {
-				b: {
-					c: [1, 2, 3],
-					d: {
-						e: [4, 5, 6],
-					},
-				},
-			},
-		};
-		const result = arrayConvertToSet(input);
-		expect(result.a.b.c).toEqual(new Set([1, 2, 3]));
-		expect(result.a.b.d.e).toEqual(new Set([4, 5, 6]));
-	});
-
-	test('配列内にオブジェクトがある場合（配列自体がSetになる）', () => {
-		const obj = { value: 1 };
-		const input = [obj, 2, 3];
-		const result = arrayConvertToSet(input);
-		expect(result).toEqual(new Set([obj, 2, 3]));
-	});
-
-	test('元のオブジェクトが変更されないことを確認', () => {
-		const input = { a: [1, 2, 3] };
-		const result = arrayConvertToSet(input);
-		expect(Array.isArray(input.a)).toBe(true);
-		expect(result.a).toBeInstanceOf(Set);
-	});
-
-	test('複数階層のオブジェクトと配列が混在するケース', () => {
-		const input = {
-			colors: ['red', 'blue', 'green'],
-			sizes: {
-				small: [1, 2, 3],
-				large: [10, 20, 30],
-			},
-			config: {
-				enabled: true,
-				tags: ['tag1', 'tag2'],
-			},
-		};
-		const result = arrayConvertToSet(input);
-		expect(result.colors).toEqual(new Set(['red', 'blue', 'green']));
-		expect(result.sizes.small).toEqual(new Set([1, 2, 3]));
-		expect(result.sizes.large).toEqual(new Set([10, 20, 30]));
-		expect(result.config.enabled).toBe(true);
-		expect(result.config.tags).toEqual(new Set(['tag1', 'tag2']));
-	});
+  test('配列をSetに変換する', () => {
+    const input = [1, 2, 3];
+    const result = arrayConvertToSet(input);
+    expect(result).toBeInstanceOf(Set);
+    expect(result).toEqual(new Set([1, 2, 3]));
+  });
+
+  test('重複した要素を持つ配列をSetに変換する', () => {
+    const input = [1, 2, 2, 3, 3, 3];
+    const result = arrayConvertToSet(input);
+    expect(result).toEqual(new Set([1, 2, 3]));
+  });
+
+  test('オブジェクト内の配列をSetに変換する', () => {
+    const input = { a: [1, 2, 3], b: [4, 5, 6] };
+    const result = arrayConvertToSet(input);
+    expect(result.a).toEqual(new Set([1, 2, 3]));
+    expect(result.b).toEqual(new Set([4, 5, 6]));
+  });
+
+  test('ネストしたオブジェクト内の配列をSetに変換する', () => {
+    const input = {
+      level1: {
+        level2: {
+          arr: [1, 2, 3],
+        },
+      },
+    };
+    const result = arrayConvertToSet(input);
+    expect(result.level1.level2.arr).toEqual(new Set([1, 2, 3]));
+  });
+
+  test('配列とオブジェクトが混在する場合', () => {
+    const input = {
+      a: [1, 2, 3],
+      b: {
+        c: [4, 5, 6],
+        d: 'string',
+      },
+      e: 100,
+    };
+    const result = arrayConvertToSet(input);
+    expect(result.a).toEqual(new Set([1, 2, 3]));
+    expect(result.b.c).toEqual(new Set([4, 5, 6]));
+    expect(result.b.d).toBe('string');
+    expect(result.e).toBe(100);
+  });
+
+  test('プリミティブ値はそのまま返す', () => {
+    expect(arrayConvertToSet(1)).toBe(1);
+    expect(arrayConvertToSet('string')).toBe('string');
+    expect(arrayConvertToSet(true)).toBe(true);
+    expect(arrayConvertToSet(null)).toBe(null);
+    expect(arrayConvertToSet(undefined)).toBe(undefined);
+  });
+
+  test('空配列をSetに変換する', () => {
+    const input: never[] = [];
+    const result = arrayConvertToSet(input);
+    expect(result).toEqual(new Set());
+  });
+
+  test('空オブジェクトをそのまま返す', () => {
+    const input = {};
+    const result = arrayConvertToSet(input);
+    expect(result).toEqual({});
+  });
+
+  test('深くネストしたオブジェクトと配列の変換', () => {
+    const input = {
+      a: {
+        b: {
+          c: [1, 2, 3],
+          d: {
+            e: [4, 5, 6],
+          },
+        },
+      },
+    };
+    const result = arrayConvertToSet(input);
+    expect(result.a.b.c).toEqual(new Set([1, 2, 3]));
+    expect(result.a.b.d.e).toEqual(new Set([4, 5, 6]));
+  });
+
+  test('配列内にオブジェクトがある場合（配列自体がSetになる）', () => {
+    const obj = { value: 1 };
+    const input = [obj, 2, 3];
+    const result = arrayConvertToSet(input);
+    expect(result).toEqual(new Set([obj, 2, 3]));
+  });
+
+  test('元のオブジェクトが変更されないことを確認', () => {
+    const input = { a: [1, 2, 3] };
+    const result = arrayConvertToSet(input);
+    expect(Array.isArray(input.a)).toBe(true);
+    expect(result.a).toBeInstanceOf(Set);
+  });
+
+  test('複数階層のオブジェクトと配列が混在するケース', () => {
+    const input = {
+      colors: ['red', 'blue', 'green'],
+      sizes: {
+        small: [1, 2, 3],
+        large: [10, 20, 30],
+      },
+      config: {
+        enabled: true,
+        tags: ['tag1', 'tag2'],
+      },
+    };
+    const result = arrayConvertToSet(input);
+    expect(result.colors).toEqual(new Set(['red', 'blue', 'green']));
+    expect(result.sizes.small).toEqual(new Set([1, 2, 3]));
+    expect(result.sizes.large).toEqual(new Set([10, 20, 30]));
+    expect(result.config.enabled).toBe(true);
+    expect(result.config.tags).toEqual(new Set(['tag1', 'tag2']));
+  });
 });

package/config/helper.ts

@@ -1,24 +1,18 @@
 type PlainObject = Record<string, unknown>;
 
 function isObj(value: unknown): value is PlainObject {
-	return value !== null && typeof value === 'object' && !Array.isArray(value);
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
 type DeepMergeResult<T, U> = T extends PlainObject
-	? U extends PlainObject
-		? {
-				[K in keyof T | keyof U]: K extends keyof U
-					? K extends keyof T
-						? DeepMergeResult<T[K], U[K]>
-						: U[K]
-					: K extends keyof T
-						? T[K]
-						: never;
-			}
-		: T
-	: U extends PlainObject
-		? U
-		: T;
+  ? U extends PlainObject
+    ? {
+        [K in keyof T | keyof U]: K extends keyof U ? (K extends keyof T ? DeepMergeResult<T[K], U[K]> : U[K]) : K extends keyof T ? T[K] : never;
+      }
+    : T
+  : U extends PlainObject
+    ? U
+    : T;
 
 /**
  * 深いマージを行う関数
@@ -27,27 +21,27 @@ type DeepMergeResult<T, U> = T extends PlainObject
  * @returns マージされたオブジェクト
  */
 export function objDeepMerge<T extends Record<string, unknown>, U extends Record<string, unknown>>(origin: T, source: U): DeepMergeResult<T, U> {
-	const result = { ...origin } as Record<string, unknown>;
+  const result = { ...origin } as Record<string, unknown>;
 
-	for (const key in source) {
-		if (Object.hasOwn(source, key)) {
-			const originValue = result[key];
-			const sourceValue = (source as Record<string, unknown>)[key];
+  for (const key in source) {
+    if (Object.hasOwn(source, key)) {
+      const originValue = result[key];
+      const sourceValue = (source as Record<string, unknown>)[key];
 
-			if (!originValue) {
-				// origin側に存在しない新たなキーの場合はそのまま追加する
-				result[key] = sourceValue;
-			} else if (isObj(sourceValue) && isObj(originValue)) {
-				// どちらもオブジェクトの場合は再帰的にマージ
-				result[key] = objDeepMerge(originValue, sourceValue);
-			} else {
-				// どちらかのデータがobjectではない場合、そのまま上書き
-				result[key] = sourceValue;
-			}
-		}
-	}
+      if (!originValue) {
+        // origin側に存在しない新たなキーの場合はそのまま追加する
+        result[key] = sourceValue;
+      } else if (isObj(sourceValue) && isObj(originValue)) {
+        // どちらもオブジェクトの場合は再帰的にマージ
+        result[key] = objDeepMerge(originValue, sourceValue);
+      } else {
+        // どちらかのデータがobjectではない場合、そのまま上書き
+        result[key] = sourceValue;
+      }
+    }
+  }
 
-	return result as DeepMergeResult<T, U>;
+  return result as DeepMergeResult<T, U>;
 }
 
 type DeepArrayToSet<T> = T extends unknown[] ? Set<T[number]> : T extends PlainObject ? { [K in keyof T]: DeepArrayToSet<T[K]> } : T;
@@ -58,22 +52,22 @@ type DeepArrayToSet<T> = T extends unknown[] ? Set<T[number]> : T extends PlainO
  * @returns 変換されたオブジェクト
  */
 export function arrayConvertToSet<T>(obj: T): DeepArrayToSet<T> {
-	// 配列の場合はSetに変換
-	if (Array.isArray(obj)) {
-		return new Set(obj) as DeepArrayToSet<T>;
-	}
+  // 配列の場合はSetに変換
+  if (Array.isArray(obj)) {
+    return new Set(obj) as DeepArrayToSet<T>;
+  }
 
-	// オブジェクトの場合は再帰的に処理
-	if (isObj(obj)) {
-		const result: Record<string, unknown> = {};
-		for (const key in obj) {
-			if (Object.hasOwn(obj, key)) {
-				result[key] = arrayConvertToSet(obj[key]);
-			}
-		}
-		return result as DeepArrayToSet<T>;
-	}
+  // オブジェクトの場合は再帰的に処理
+  if (isObj(obj)) {
+    const result: Record<string, unknown> = {};
+    for (const key in obj) {
+      if (Object.hasOwn(obj, key)) {
+        result[key] = arrayConvertToSet(obj[key]);
+      }
+    }
+    return result as DeepArrayToSet<T>;
+  }
 
-	// その他の値はそのまま返す
-	return obj as DeepArrayToSet<T>;
+  // その他の値はそのまま返す
+  return obj as DeepArrayToSet<T>;
 }

package/config/index.ts

@@ -3,7 +3,7 @@ import userConfig from 'lism-css/config.js'; // ユーザーが上書きでき
 import { objDeepMerge, arrayConvertToSet } from './helper';
 
 interface Window {
-	_LISM_CSS_CONFIG_: Partial<typeof defaultConfig>;
+  _LISM_CSS_CONFIG_: Partial<typeof defaultConfig>;
 }
 declare const window: Window;
 
@@ -12,7 +12,7 @@ let mergedConfig = objDeepMerge(defaultConfig, userConfig);
 
 // ブラウザ環境で window._LISM_CSS_CONFIG_ があればランタイムでマージ
 if (typeof window !== 'undefined' && window._LISM_CSS_CONFIG_) {
-	mergedConfig = objDeepMerge(mergedConfig, window._LISM_CSS_CONFIG_);
+  mergedConfig = objDeepMerge(mergedConfig, window._LISM_CSS_CONFIG_);
 }
 
 export const CONFIG = mergedConfig;
@@ -20,8 +20,8 @@ export const CONFIG = mergedConfig;
 const { tokens, props, states } = CONFIG;
 
 const tokensWithColor = {
-	color: [...tokens.c.values, ...tokens.palette.values],
-	...tokens,
+  color: [...tokens.c.values, ...tokens.palette.values],
+  ...tokens,
 } as const;
 
 // 配列を Set化.

package/config/tsconfig.json

@@ -1,18 +1,18 @@
 {
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"declaration": true,
-		"declarationMap": false,
-		"declarationDir": "../dist/config",
-		"emitDeclarationOnly": true,
-		"outDir": "../dist/config",
-		"rootDir": ".",
-		"composite": false,
-		"baseUrl": "..",
-		"paths": {
-			"lism-css/config.js": ["./config.js"]
-		}
-	},
-	"include": ["./**/*.ts"],
-	"exclude": ["**/*.test.ts"]
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": false,
+    "declarationDir": "../dist/config",
+    "emitDeclarationOnly": true,
+    "outDir": "../dist/config",
+    "rootDir": ".",
+    "composite": false,
+    "baseUrl": "..",
+    "paths": {
+      "lism-css/config.js": ["./config.js"]
+    }
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["**/*.test.ts"]
 }