@versatiles/style 5.2.6 → 5.2.7

package/src/lib/utils.test.ts

@@ -0,0 +1,197 @@
+import { Color } from '../color/index.js';
+import { deepClone, isSimpleObject, isBasicType, deepMerge, resolveUrl, basename } from './utils.js';
+
+describe('deepClone', () => {
+	it('clones primitive types correctly', () => {
+		expect(deepClone(10)).toBe(10);
+		expect(deepClone(true)).toBe(true);
+		expect(deepClone('string')).toBe('string');
+	});
+
+	it('clones an array correctly', () => {
+		const array = [1, 2, { a: 'b' }];
+		const clonedArray = deepClone(array);
+		expect(clonedArray).toEqual(array);
+		expect(clonedArray).not.toBe(array);
+		expect(clonedArray[2]).not.toBe(array[2]);
+	});
+
+	it('clones a simple object correctly', () => {
+		const obj = { a: 'b', c: 1, d: true };
+		const clonedObj = deepClone(obj);
+		expect(clonedObj).toEqual(obj);
+		expect(clonedObj).not.toBe(obj);
+	});
+
+	it('clones a Color instance correctly', () => {
+		const color = Color.parse('#FF5733');
+		const clonedColor = deepClone(color);
+		expect(clonedColor.asHex()).toBe(color.asHex());
+		expect(clonedColor).not.toBe(color);
+	});
+
+	it('throws an error for non-implemented types', () => {
+		const func = (): boolean => true;
+		expect(() => deepClone(func)).toThrow('Not implemented yet: "function" case');
+	});
+
+	it('throws an error for unexpected cases', () => {
+		const obj = Object.create(null); // No prototype
+		expect(() => deepClone(obj)).toThrow();
+	});
+});
+
+describe('isSimpleObject', () => {
+	it('identifies simple objects correctly', () => {
+		expect(isSimpleObject({ a: 1 })).toBe(true);
+		expect(isSimpleObject({})).toBe(true);
+	});
+
+	it('rejects non-objects', () => {
+		expect(isSimpleObject(1)).toBe(false);
+		expect(isSimpleObject('a')).toBe(false);
+		expect(isSimpleObject(true)).toBe(false);
+	});
+
+	it('rejects arrays', () => {
+		expect(isSimpleObject([1, 2, 3])).toBe(false);
+	});
+
+	it('rejects objects with prototype properties', () => {
+		class MyClass {
+			readonly property = true;
+		}
+		expect(isSimpleObject(new MyClass())).toBe(false);
+	});
+
+	it('rejects null objects', () => {
+		expect(isSimpleObject(null)).toBe(false);
+	});
+});
+
+describe('isBasicType', () => {
+	it('returns true for basic types', () => {
+		expect(isBasicType(1)).toBe(true);
+		expect(isBasicType('string')).toBe(true);
+		expect(isBasicType(true)).toBe(true);
+		expect(isBasicType(undefined)).toBe(true);
+	});
+
+	it('returns false for objects', () => {
+		expect(isBasicType({})).toBe(false);
+		expect(isBasicType([])).toBe(false);
+		expect(isBasicType(Color.parse('#FF5733'))).toBe(false);
+	});
+
+	it('throws an error for unsupported types like functions', () => {
+		expect(() => isBasicType(() => true)).toThrow('unknown type: function');
+	});
+});
+
+describe('deepMerge', () => {
+	it('merges simple objects correctly', () => {
+		const target = { a: 1, b: 2, c: 3 };
+		const source = { b: 3, c: 4 };
+		const result = deepMerge(target, source);
+		expect(result).toEqual({ a: 1, b: 3, c: 4 });
+	});
+
+	it('merges nested objects correctly', () => {
+		const target = { a: { d: 4, e: 3 }, b: 2 } as { a: { d?: number, e: number }, b: number };
+		const source = { a: { e: 5 }, b: 3 };
+		const result = deepMerge(target, source);
+		expect(result).toEqual({ a: { d: 4, e: 5 }, b: 3 });
+	});
+
+	it('overrides primitives with objects', () => {
+		const target = { a: 1, b: 2 } as { a: object | number, b: object | number };
+		const source = { a: { d: 4 }, b: { e: 5 } };
+		const result = deepMerge(target, source);
+		expect(result).toEqual({ a: { d: 4 }, b: { e: 5 } });
+	});
+
+	it('merges Color instances correctly', () => {
+		const target = { color: Color.parse('#FF5733') };
+		const source = { color: Color.parse('#33FF57') };
+		const result = deepMerge(target, source);
+		expect(result.color.asHex()).toBe('#33FF57');
+	});
+
+	it('throws error for unsupported cases', () => {
+		const target = { a: (): boolean => false } as { a: (() => boolean) | object };
+		const source = { a: { b: 1 } };
+		expect(() => deepMerge(target, source)).toThrow('Not implemented yet: "function" case');
+	});
+});
+
+describe('resolveUrl', () => {
+	it('resolves a relative URL with a base URL', () => {
+		expect(resolveUrl('http://example.com/', 'path/page')).toBe('http://example.com/path/page');
+	});
+
+	it('returns the same URL if the base URL is empty', () => {
+		expect(resolveUrl('', 'http://example.com/path/page')).toBe('http://example.com/path/page');
+	});
+
+	it('returns the correct URL if an absolute URL is used', () => {
+		expect(resolveUrl('http://example1.com', 'http://example.com/path/page')).toBe('http://example.com/path/page');
+	});
+
+	it('handles URLs with special characters', () => {
+		expect(resolveUrl('http://example.com/', 'path/{param}')).toBe('http://example.com/path/{param}');
+	});
+
+	it('handles URLs already containing encoded special characters', () => {
+		expect(resolveUrl('http://example.com/', 'path/%7Bparam%7D')).toBe('http://example.com/path/{param}');
+	});
+
+	it('throws an error for invalid base URLs', () => {
+		expect(() => resolveUrl('invalid-base', 'path/page')).toThrow('Invalid URL');
+	});
+});
+
+describe('basename', () => {
+	it('returns the last segment of a URL-like string', () => {
+		expect(basename('http://example.com/path/to/resource')).toBe('resource');
+		expect(basename('/path/to/file.txt')).toBe('file.txt');
+		expect(basename('folder/subfolder/item')).toBe('item');
+	});
+
+	it('removes trailing slashes before extracting basename', () => {
+		expect(basename('http://example.com/path/to/resource/')).toBe('resource');
+		expect(basename('/path/to/folder/')).toBe('folder');
+		expect(basename('directory/')).toBe('directory');
+	});
+
+	it('returns an empty string for root paths or URLs ending with a slash', () => {
+		expect(basename('http://example.com/')).toBe('');
+		expect(basename('/')).toBe('');
+		expect(basename('////')).toBe('');
+	});
+
+	it('returns the full string if no slashes are present', () => {
+		expect(basename('file')).toBe('file');
+		expect(basename('filename.txt')).toBe('filename.txt');
+		expect(basename('no/slash')).toBe('slash');
+	});
+
+	it('handles empty and null inputs gracefully', () => {
+		expect(basename('')).toBe('');
+		expect(basename(null as unknown as string)).toBe('');
+		expect(basename(undefined as unknown as string)).toBe('');
+	});
+
+	it('handles URLs with query strings or fragments', () => {
+		expect(basename('http://example.com/path/to/resource?query=param')).toBe('resource');
+		expect(basename('http://example.com/path/to/resource#section')).toBe('resource');
+		expect(basename('/path/to/resource?query=param')).toBe('resource');
+		expect(basename('/path/to/resource#section')).toBe('resource');
+	});
+
+	it('handles URLs with special characters', () => {
+		expect(basename('http://example.com/path/to/resource%20name')).toBe('resource%20name');
+		expect(basename('/path/to/resource-name')).toBe('resource-name');
+		expect(basename('http://example.com/resource_name/')).toBe('resource_name');
+		expect(basename('/path/to/resource+name')).toBe('resource+name');
+	});
+});

package/src/lib/utils.ts

@@ -0,0 +1,134 @@
+import { Color } from '../color/index.js';
+
+// Utility function to deep clone an object
+export function deepClone<T>(obj: T): T {
+	const type = typeof obj;
+	if (type !== 'object') {
+		switch (type) {
+			case 'boolean':
+			case 'number':
+			case 'string':
+			case 'undefined':
+				return obj;
+			default: throw new Error(`Not implemented yet: "${type}" case`);
+		}
+	}
+
+	if (isSimpleObject(obj)) {
+		// @ts-expect-error: Too complicated to handle
+		return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, deepClone(value)]));
+	}
+
+	if (obj instanceof Array) {
+		// @ts-expect-error: Too complicated to handle
+		return obj.map((e: unknown) => deepClone(e));
+	}
+
+	if (obj instanceof Color) {
+		return obj.clone() as T;
+	}
+
+	if (obj == null) return obj;
+
+	console.log('obj', obj);
+	console.log('obj.prototype', Object.getPrototypeOf(obj));
+	throw Error();
+}
+
+export function isSimpleObject(item: unknown): item is object {
+	if (item === null) return false;
+	if (typeof item !== 'object') return false;
+	if (Array.isArray(item)) return false;
+	const prototypeKeyCount: number = Object.keys(Object.getPrototypeOf(item) as object).length;
+	if (prototypeKeyCount !== 0) return false;
+	if (item.constructor.name !== 'Object') return false;
+	return true;
+}
+
+export function isBasicType(item: unknown): item is boolean | number | string | undefined {
+	switch (typeof item) {
+		case 'boolean':
+		case 'number':
+		case 'string':
+		case 'undefined':
+			return true;
+		case 'object':
+			return false;
+		default:
+			throw Error('unknown type: ' + typeof item);
+	}
+}
+
+export function deepMerge<T extends object>(source0: T, ...sources: Partial<T>[]): T {
+	const target: T = deepClone(source0);
+
+	for (const source of sources) {
+		if (typeof source !== 'object') continue;
+		for (const key in source) {
+			if (!(key in source)) continue;
+
+			const sourceValue = source[key] as T[typeof key];
+
+			// *********
+			// overwrite
+			// *********
+			switch (typeof sourceValue) {
+				case 'number':
+				case 'string':
+				case 'boolean':
+					target[key] = sourceValue;
+					continue;
+				default:
+			}
+
+			if (isBasicType(target[key])) {
+				target[key] = deepClone(sourceValue);
+				continue;
+			}
+
+			if (sourceValue instanceof Color) {
+				// @ts-expect-error: Too complicated to handle
+				target[key] = sourceValue.clone();
+				continue;
+			}
+
+			if (isSimpleObject(target[key]) && isSimpleObject(sourceValue)) {
+				target[key] = deepMerge(target[key], sourceValue);
+				continue;
+			}
+
+			// *********
+			// merge
+			// *********
+
+			if (isSimpleObject(target[key]) && isSimpleObject(sourceValue)) {
+				target[key] = deepMerge(target[key], sourceValue);
+				continue;
+			}
+
+			console.log('target[key]:', target[key]);
+			console.log('source[key]:', source[key]);
+			throw Error('unpredicted case');
+		}
+	}
+	return target;
+}
+
+export function resolveUrl(base: string, url: string): string {
+	if (!base) return url;
+	url = new URL(url, base).href;
+	url = url.replace(/%7B/gi, '{');
+	url = url.replace(/%7D/gi, '}');
+	return url;
+}
+
+export function basename(url: string): string {
+	if (!url) return '';
+	try {
+		url = new URL(url, 'http://example.org').pathname;
+	} catch (_) {
+		// ignore
+	}
+	url = url.replace(/\/+$/, '');
+	return url.split('/').pop() ?? '';
+}

package/{dist/shortbread/index.d.ts → src/shortbread/index.ts}

@@ -1,2 +1,3 @@
+
 export { getShortbreadTemplate } from './template.js';
 export { getShortbreadLayers } from './layers.js';

package/src/shortbread/layers.test.ts

@@ -0,0 +1,36 @@
+import type { FillLayerSpecification, SymbolLayerSpecification } from '@maplibre/maplibre-gl-style-spec';
+import { getShortbreadLayers } from './layers.js';
+import { Language } from '../style_builder/types.js';
+
+describe('layers', () => {
+	it('should return an array of MaplibreLayer', () => {
+		const language: Language = 'en';
+		const layers = getShortbreadLayers({ language });
+
+		expect(Array.isArray(layers)).toBe(true);
+		expect(layers).not.toHaveLength(0);
+		layers.forEach((layer) => {
+			expect(layer).toHaveProperty('id');
+			expect(layer).toHaveProperty('type');
+		});
+	});
+
+	it('should handle language suffix correctly', () => {
+		const language: Language = 'en';
+		const layers = getShortbreadLayers({ language });
+		const labelLayer = layers.find((layer) => layer.id === 'label-street-pedestrian') as SymbolLayerSpecification;
+
+		expect(labelLayer).toBeDefined();
+
+		expect(labelLayer.layout?.['text-field']).toContain('{name_en}');
+	});
+
+	it('should create appropriate filters for land layers', () => {
+		const language: Language = 'en';
+		const layers = getShortbreadLayers({ language });
+		const landLayer = layers.find((layer) => layer.id === 'land-agriculture') as FillLayerSpecification;
+
+		expect(landLayer).toBeDefined();
+		expect(landLayer.filter).toEqual(['all', ['in', 'kind', 'brownfield', 'farmland', 'farmyard', 'greenfield', 'greenhouse_horticulture', 'orchard', 'plant_nursery', 'vineyard']]);
+	});
+});