mutts 1.0.0 → 1.0.1

package/src/indexable.test.ts

@@ -1,388 +0,0 @@
-import { getAt, Indexable, setAt } from './indexable'
-
-// TODO: get/set became this: based
-describe('Indexable', () => {
-	describe('Indexable(base, accessor)', () => {
-		it('should create indexable class with custom accessor', () => {
-			class Base {
-				constructor(public items: string[]) {}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase(['a', 'b', 'c'])
-
-			expect(instance[0]).toBe('a')
-			expect(instance[1]).toBe('b')
-			expect(instance[2]).toBe('c')
-			expect(instance.items).toEqual(['a', 'b', 'c'])
-		})
-
-		it('should handle different item types', () => {
-			class Base {
-				constructor(public numbers: number[]) {}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.numbers[index] * 2
-				},
-				set: function (this: Base, index, value) {
-					this.numbers[index] = value / 2
-				},
-			})
-			const instance = new IndexableBase([1, 2, 3])
-
-			expect(instance[0]).toBe(2)
-			expect(instance[1]).toBe(4)
-			expect(instance[2]).toBe(6)
-		})
-
-		it('should preserve base class methods', () => {
-			class Base {
-				constructor(public items: string[]) {}
-				getLength() {
-					return this.items.length
-				}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase(['a', 'b'])
-
-			expect(instance.getLength()).toBe(2)
-			expect(instance[0]).toBe('a')
-		})
-	})
-
-	describe('Indexable(base with getAt and setAt methods)', () => {
-		it('should use the base class getAt and setAt methods', () => {
-			class Base {
-				constructor(public items: string[]) {}
-				[getAt](index: number): string {
-					return this.items[index]
-				}
-				[setAt](index: number, value: string): void {
-					this.items[index] = value
-				}
-			}
-
-			const IndexableBase = Indexable(Base)
-			const instance = new IndexableBase(['x', 'y', 'z'])
-
-			expect(instance[0]).toBe('x')
-			instance[0] = 'a'
-			expect(instance[0]).toBe('a')
-			expect(instance.items[0]).toBe('a')
-		})
-
-		it('should work with custom getAt and setAt implementation', () => {
-			class Base {
-				constructor(public numbers: number[]) {}
-				[getAt](index: number): number {
-					return this.numbers[index] * 3
-				}
-				[setAt](index: number, value: number): void {
-					this.numbers[index] = value / 3
-				}
-			}
-
-			const IndexableBase = Indexable(Base)
-			const instance = new IndexableBase([1, 2, 3])
-
-			expect(instance[0]).toBe(3)
-			instance[0] = 9
-			expect(instance[0]).toBe(9)
-			expect(instance.numbers[0]).toBe(3)
-		})
-
-		it('should throw when setAt method is missing', () => {
-			class Base {
-				constructor(public items: string[]) {}
-				[getAt](index: number): string {
-					return this.items[index]
-				}
-				// Missing setAt method
-			}
-
-			const IndexableBase = Indexable(Base)
-			const instance = new IndexableBase(['x', 'y'])
-
-			expect(instance[0]).toBe('x')
-			expect(() => {
-				instance[0] = 'z'
-			}).toThrow('Indexable class has read-only numeric index access')
-		})
-	})
-
-	describe('Indexable()', () => {
-		it('should create abstract class with abstract getAt method', () => {
-			const AbstractIndexable = Indexable<string>()
-
-			//@ts-expect-error Should be abstract
-			void new AbstractIndexable()
-
-			// Should have abstract getAt method
-			class Concrete extends AbstractIndexable {
-				constructor(private items: string[]) {
-					super()
-				}
-				[getAt](index: number): string {
-					return this.items[index]
-				}
-			}
-
-			const instance = new Concrete(['p', 'q', 'r'])
-			expect(instance[0]).toBe('p')
-			expect(instance[1]).toBe('q')
-			expect(instance[2]).toBe('r')
-		})
-
-		it('should enforce getAt method implementation', () => {
-			const AbstractIndexable = Indexable<number>()
-			//@ts-expect-error Should be abstract
-			class Invalid extends AbstractIndexable {}
-
-			// JavaScript doesn't enforce abstract methods at runtime
-			// So instantiation won't throw, but calling the missing method will
-			const instance = new Invalid()
-			expect(() => instance[0]).toThrow()
-		})
-	})
-
-	describe('edge cases', () => {
-		it('should handle out of bounds access', () => {
-			class Base {
-				constructor(public items: string[]) {}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase(['a', 'b'])
-
-			expect(instance[5]).toBeUndefined()
-			expect(instance[-1]).toBeUndefined()
-		})
-
-		it('should handle empty arrays', () => {
-			class Base {
-				constructor(public items: string[]) {}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase([])
-
-			expect(instance[0]).toBeUndefined()
-		})
-
-		it('should not interfere with non-numeric properties', () => {
-			class Base {
-				constructor(public items: string[]) {}
-				length = 42
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase(['a', 'b'])
-
-			expect(instance.length).toBe(42)
-			expect(instance.items).toEqual(['a', 'b'])
-		})
-
-		it('should not interfere with setting non-numeric properties', () => {
-			class Base {
-				constructor(public items: string[]) {}
-				length = 42
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			})
-			const instance = new IndexableBase(['a', 'b'])
-
-			instance.length = 100
-			expect(instance.length).toBe(100)
-		})
-	})
-
-	describe('integration tests', () => {
-		it('should work with complex objects', () => {
-			class Person {
-				constructor(
-					public name: string,
-					public age: number
-				) {}
-			}
-
-			class PersonList {
-				constructor(public people: Person[]) {}
-				[getAt](index: number): Person {
-					return this.people[index]
-				}
-				[setAt](index: number, person: Person): void {
-					this.people[index] = person
-				}
-			}
-
-			const IndexablePersonList = Indexable(PersonList)
-			const people = [new Person('Alice', 30), new Person('Bob', 25), new Person('Charlie', 35)]
-			const instance = new IndexablePersonList(people)
-
-			expect((instance[0] as Person).name).toBe('Alice')
-			instance[0] = new Person('Alice Updated', 31)
-			expect((instance[0] as Person).name).toBe('Alice Updated')
-			expect((instance[0] as Person).age).toBe(31)
-			expect(instance.people[0].name).toBe('Alice Updated')
-		})
-
-		it('should support multiple inheritance levels', () => {
-			class Base {
-				constructor(public items: string[]) {}
-			}
-
-			class Extended extends Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					this.items[index] = value
-				},
-			}) {
-				constructor(
-					items: string[],
-					public extra: string
-				) {
-					super(items)
-				}
-			}
-
-			const instance = new Extended(['a', 'b'], 'extra')
-			expect(instance[0]).toBe('a')
-			expect(instance.extra).toBe('extra')
-		})
-
-		it('should support setting with custom logic', () => {
-			class Base {
-				constructor(public items: string[]) {}
-			}
-
-			const IndexableBase = Indexable(Base, {
-				get: function (this: Base, index) {
-					return this.items[index]
-				},
-				set: function (this: Base, index, value) {
-					// Custom logic: convert to uppercase
-					this.items[index] = value.toUpperCase()
-				},
-			})
-			const instance = new IndexableBase(['a', 'b', 'c'])
-
-			instance[1] = 'x'
-			expect(instance[1]).toBe('X')
-			expect(instance.items[1]).toBe('X')
-		})
-	})
-
-	describe('Indexable(accessor)', () => {
-		it('should create indexable object with custom accessor', () => {
-			const IndexableObj = Indexable({
-				get: function (this: any, index: number) {
-					return this._arr?.[index]
-				},
-				set: function (this: any, index: number, value: any) {
-					if (!this._arr) this._arr = []
-					this._arr[index] = value
-				},
-			})
-			const instance = new IndexableObj() as any
-			instance._arr = ['a', 'b', 'c']
-			expect(instance[0]).toBe('a')
-			expect(instance[1]).toBe('b')
-			expect(instance[2]).toBe('c')
-		})
-
-		it('should create indexable object with custom getter and setter', () => {
-			const IndexableObj = Indexable({
-				get: function (this: any, index: number) {
-					return this._arr?.[index]
-				},
-				set: function (this: any, index: number, value: string) {
-					if (!this._arr) this._arr = []
-					this._arr[index] = value
-				},
-			})
-			const instance = new IndexableObj() as any
-			instance[0] = 'x'
-			instance[1] = 'y'
-			expect(instance[0]).toBe('x')
-			expect(instance[1]).toBe('y')
-			expect(instance._arr[0]).toBe('x')
-			expect(instance._arr[1]).toBe('y')
-		})
-
-		it('should support transformation in setter', () => {
-			const IndexableObj = Indexable({
-				get: function (this: any, index: number) {
-					return this._arr?.[index] * 2
-				},
-				set: function (this: any, index: number, value: number) {
-					if (!this._arr) this._arr = []
-					this._arr[index] = value / 2
-				},
-			})
-			const instance = new IndexableObj() as any
-			instance._arr = [1, 2, 3]
-			instance[0] = 10
-			expect(instance[0]).toBe(10)
-			expect(instance._arr[0]).toBe(5)
-		})
-
-		it('should throw if setter is missing and assignment is attempted', () => {
-			const IndexableObj = Indexable({
-				get: function (this: any, index: number) {
-					return this._arr?.[index]
-				},
-			})
-			const instance = new IndexableObj() as any
-			expect(() => {
-				instance[0] = 'fail'
-			}).toThrow('Indexable class has read-only numeric index access')
-		})
-	})
-})

package/src/indexable.ts

@@ -1,124 +0,0 @@
-export const getAt = Symbol('getAt')
-export const setAt = Symbol('setAt')
-
-interface IndexingAt<Items = any> {
-	[getAt](index: number): Items
-}
-
-interface Accessor<T, Items> {
-	get(this: T, index: number): Items
-	set?(this: T, index: number, value: Items): void
-	getLength?(this: T): number
-	setLength?(this: T, value: number): void
-}
-
-abstract class AbstractGetAt<Items = any> {
-	abstract [getAt](index: number): Items
-}
-
-export function Indexable<Items, Base extends abstract new (...args: any[]) => any>(
-	base: Base,
-	accessor: Accessor<InstanceType<Base>, Items>
-): new (
-	...args: ConstructorParameters<Base>
-) => InstanceType<Base> & { [x: number]: Items }
-
-export function Indexable<Items>(accessor: Accessor<any, Items>): new () => { [x: number]: Items }
-
-export function Indexable<Base extends new (...args: any[]) => IndexingAt>(
-	base: Base
-): new (
-	...args: ConstructorParameters<Base>
-) => InstanceType<Base> & { [x: number]: AtReturnType<InstanceType<Base>> }
-
-export function Indexable<Items>(): abstract new (
-	...args: any[]
-) => AbstractGetAt & { [x: number]: Items }
-
-export function Indexable<Items, Base extends abstract new (...args: any[]) => any>(
-	base?: Base | Accessor<Base, Items>,
-	accessor?: Accessor<Base, Items>
-) {
-	if (base && typeof base !== 'function') {
-		accessor = base as Accessor<Base, Items>
-		base = undefined
-	}
-	if (!base) {
-		//@ts-expect-error
-		base = class {} as Base
-	}
-	if (!accessor) {
-		accessor = {
-			get(this: any, index: number) {
-				if (typeof this[getAt] !== 'function') {
-					throw new Error('Indexable class must have an [getAt] method')
-				}
-				return this[getAt](index)
-			},
-			set(this: any, index: number, value: Items) {
-				if (typeof this[setAt] !== 'function') {
-					throw new Error('Indexable class has read-only numeric index access')
-				}
-				this[setAt](index, value)
-			},
-		}
-	}
-
-	abstract class Indexable extends (base as Base) {
-		[x: number]: Items
-	}
-
-	Object.setPrototypeOf(
-		Indexable.prototype,
-		new Proxy((base as Base).prototype, {
-			//@ts-expect-error
-			[Symbol.toStringTag]: 'MutTs Indexable',
-			get(target, prop, receiver) {
-				if (prop in target) {
-					const getter = Object.getOwnPropertyDescriptor(target, prop)?.get
-					return getter ? getter.call(receiver) : target[prop]
-				}
-				if (typeof prop === 'string') {
-					if (prop === 'length' && accessor.getLength) return accessor.getLength.call(receiver)
-					const numProp = Number(prop)
-					if (!Number.isNaN(numProp)) {
-						return accessor.get!.call(receiver, numProp) as Items
-					}
-				}
-				return undefined
-			},
-			set(target, prop, value, receiver) {
-				if (prop in target) {
-					const setter = Object.getOwnPropertyDescriptor(target, prop)?.set
-					if (setter) setter.call(receiver, value)
-					else target[prop] = value
-					return true
-				}
-				if (typeof prop === 'string') {
-					if (prop === 'length' && accessor.setLength) {
-						accessor.setLength.call(receiver, value)
-						return true
-					}
-					const numProp = Number(prop)
-					if (!Number.isNaN(numProp)) {
-						if (!accessor.set) {
-							throw new Error('Indexable class has read-only numeric index access')
-						}
-						accessor.set!.call(receiver, numProp, value)
-						return true
-					}
-				}
-				Object.defineProperty(receiver, prop, {
-					value,
-					writable: true,
-					enumerable: true,
-					configurable: true,
-				})
-				return true
-			},
-		})
-	)
-	return Indexable
-}
-
-type AtReturnType<T> = T extends { [getAt](index: number): infer R } ? R : never

package/src/promiseChain.test.ts

@@ -1,201 +0,0 @@
-import { chainPromise } from './promiseChain'
-
-describe('chain', () => {
-	describe('basic functionality', () => {
-		it('should return non-promise values as-is', () => {
-			const value = { name: 'test', value: 42 }
-			const result = chainPromise(value)
-			expect(result).toEqual(value)
-		})
-
-		it('should chain method calls on resolved promise values', async () => {
-			const obj = {
-				getName: () => 'John',
-				getAge: () => 30,
-				getInfo: () => ({ name: 'John', age: 30 }),
-			}
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).getName()
-			expect(result).toBe('John')
-		})
-
-		it('should support multiple method chaining', async () => {
-			const obj = {
-				getName: () => 'John',
-				getAge: () => 30,
-				getInfo: () => ({ name: 'John', age: 30 }),
-			}
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).getInfo().name
-			expect(result).toBe('John')
-		})
-
-		it('should handle async methods', async () => {
-			const obj = {
-				getName: async () => 'John',
-				getAge: async () => 30,
-			}
-			const promise = Promise.resolve(obj)
-
-			//const result = await chainPromise(promise).getName()
-			const chained = chainPromise(promise)
-			const getName = chained.getName
-			const result = await getName()
-			expect(result).toBe('John')
-		})
-
-		it('should handle methods with parameters', async () => {
-			const obj = {
-				add: (a: number, b: number) => a + b,
-				multiply: (a: number, b: number) => a * b,
-			}
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).add(5, 3)
-			expect(result).toBe(8)
-		})
-	})
-
-	describe('function calls', () => {
-		it('should allow calling the resolved value as a function', async () => {
-			const func = (name: string, age: number) => `${name} is ${age} years old`
-			const promise = Promise.resolve(func)
-
-			const result = await (chainPromise(promise) as any)('John', 30)
-			expect(result).toBe('John is 30 years old')
-		})
-
-		it('should handle async functions', async () => {
-			const asyncFunc = async (name: string) => `Hello ${name}`
-			const promise = Promise.resolve(asyncFunc)
-
-			const result = await (chainPromise(promise) as any)('World')
-			expect(result).toBe('Hello World')
-		})
-	})
-	/*
-	describe('caching behavior', () => {
-		it('should return the same proxy for the same promise', () => {
-			const promise = Promise.resolve({ test: () => 'value' })
-			const chain1 = chainPromise(promise)
-			const chain2 = chainPromise(promise)
-			
-			expect(chain1).toBe(chain2)
-		})
-
-		it('should not cache different promises', async () => {
-			const promise1 = Promise.resolve({ test: () => 'value1' })
-			const promise2 = Promise.resolve({ test: () => 'value2' })
-			const chain1 = chainPromise(promise1)
-			const chain2 = chainPromise(promise2)
-			
-			expect(chain1).not.toBe(chain2)
-			expect(await chain1).not.toBe(await chain2)
-		})
-	})*/
-
-	describe('complex scenarios', () => {
-		it('should handle nested object methods', async () => {
-			const obj = {
-				user: {
-					getName: () => 'John',
-					getProfile: () => ({
-						age: 30,
-						email: 'john@example.com',
-					}),
-				},
-			}
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).user.getProfile().email
-			expect(result).toBe('john@example.com')
-		})
-
-		it('should handle array methods', async () => {
-			const arr = [1, 2, 3, 4, 5]
-			const promise = Promise.resolve(arr)
-
-			//const result = await chainPromise(promise).filter(x => x > 2).map(x => x * 2)
-
-			const chained = chainPromise(promise)
-			const filtered = chained.filter((x) => {
-				return x > 2
-			})
-			const result = filtered.map((x) => {
-				return x * 2
-			})
-			const awaitResult = await result
-			expect(awaitResult).toEqual([6, 8, 10])
-		})
-
-		it('should handle methods that return promises', async () => {
-			const obj = {
-				getData: () => Promise.resolve({ id: 1, name: 'test' }),
-				processData: (data: any) => Promise.resolve({ ...data, processed: true }),
-			}
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).getData().name
-			expect(result).toBe('test')
-		})
-
-		it('should handle methods that return promises recursively', async () => {
-			const obj = {
-				getData: () => Promise.resolve({ id: 1, name: 'test' }),
-				processData: (data: any) => Promise.resolve({ ...data, processed: true }),
-			}
-
-			//const result = await chainPromise(obj).getData().name
-			const chain = chainPromise(obj)
-			const getData = chain.getData
-			const data = getData()
-			const result = await data.name
-			expect(result).toBe('test')
-		})
-	})
-
-	describe('error handling', () => {
-		it('should handle methods that throw errors', async () => {
-			const obj = {
-				errorMethod: () => {
-					throw new Error('Method error')
-				},
-			}
-			const promise = Promise.resolve(obj)
-
-			await expect(chainPromise(promise).errorMethod()).rejects.toThrow('Method error')
-		})
-	})
-
-	describe('edge cases', () => {
-		it('should handle null and undefined values', () => {
-			expect(chainPromise(null)).toBeNull()
-			expect(chainPromise(undefined)).toBeUndefined()
-		})
-
-		it('should handle primitive values', () => {
-			expect(chainPromise(42)).toBe(42)
-			expect(chainPromise('string')).toBe('string')
-			expect(chainPromise(true)).toBe(true)
-		})
-
-		it('should handle objects without methods', async () => {
-			const obj = { name: 'test', value: 42 }
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise).name
-			expect(result).toBe('test')
-		})
-
-		it('should handle symbols as property names', async () => {
-			const sym = Symbol('test')
-			const obj = { [sym]: () => 'symbol value' }
-			const promise = Promise.resolve(obj)
-
-			const result = await chainPromise(promise)[sym]()
-			expect(result).toBe('symbol value')
-		})
-	})
-})