archstone 1.2.0 → 1.2.1

package/README.md

@@ -211,11 +211,14 @@ export interface AuditRepository extends Creatable<AuditLog> {}
 
 | Import | Contents |
 |---|---|
+| `archstone` | Everything |
 | `archstone/core` | `Either`, `ValueObject`, `UniqueEntityId`, `WatchedList`, `Optional` |
 | `archstone/domain` | All domain exports |
 | `archstone/domain/enterprise` | `Entity`, `AggregateRoot`, `DomainEvent`, `DomainEvents`, `EventHandler` |
 | `archstone/domain/application` | `UseCase`, `UseCaseError`, repository contracts |
 
+All sub-paths share type declarations via a common chunk — mixing imports from multiple sub-paths is fully type-safe with no duplicate declaration conflicts.
+
 ---
 
 ## Architecture

package/dist/core/index.d.ts

@@ -1,270 +1,2 @@
-/**
-* Represents the left side of an {@link Either} — conventionally used for
-* failure or error values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Left<
-	L,
-	R
-> {
-	readonly value: L;
-	constructor(value: L);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* Represents the right side of an {@link Either} — conventionally used for
-* success values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Right<
-	L,
-	R
-> {
-	readonly value: R;
-	constructor(value: R);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* A discriminated union that represents a value of one of two possible types.
-*
-* Commonly used as a type-safe alternative to throwing exceptions — the left
-* side carries an error, and the right side carries a success value.
-*
-* Use the {@link left} and {@link right} helper functions to construct values,
-* and `isLeft()` / `isRight()` to narrow the type.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*
-* @example
-* ```ts
-* type FindUserResult = Either<NotFoundError, User>
-*
-* function findUser(id: string): FindUserResult {
-*   const user = db.find(id)
-*   if (!user) return left(new NotFoundError("User", id))
-*   return right(user)
-* }
-*
-* const result = findUser("123")
-*
-* if (result.isLeft()) {
-*   console.error(result.value) // NotFoundError
-* } else {
-*   console.log(result.value)   // User
-* }
-* ```
-*/
-type Either<
-	L,
-	R
-> = Left<L, R> | Right<L, R>;
-/**
-* Constructs a {@link Left} value, representing a failure.
-*
-* @param value - The error or failure value
-*/
-declare const left: <
-	L,
-	R
->(value: L) => Either<L, R>;
-/**
-* Constructs a {@link Right} value, representing a success.
-*
-* @param value - The success value
-*/
-declare const right: <
-	L,
-	R
->(value: R) => Either<L, R>;
-/**
-* Make some property optional on type
-*
-* @example
-* ```typescript
-* type Post {
-*  id: string;
-*  name: string;
-*  email: string;
-* }
-*
-* Optional<Post, 'id' | 'email'>
-* ```
-*/
-type Optional<
-	T,
-	K extends keyof T
-> = Pick<Partial<T>, K> & Omit<T, K>;
-/**
-* Represents a unique identifier for a domain entity.
-*
-* Wraps a UUID v7 string, which is time-sortable and ideal for database
-* indexing. A new identifier is generated automatically if no value is provided.
-*
-* @example
-* ```ts
-* // auto-generated
-* const id = new UniqueEntityId()
-*
-* // from existing value (e.g. reconstructing from database)
-* const id = new UniqueEntityId("0195d810-5b3e-7000-8e3e-1a2b3c4d5e6f")
-* ```
-*/
-declare class UniqueEntityId {
-	private readonly value;
-	constructor(value?: string);
-	/**
-	* Returns the identifier as a primitive string.
-	* Useful for serialization and database persistence.
-	*/
-	toValue(): string;
-	/**
-	* Returns the string representation of the identifier.
-	*/
-	toString(): string;
-	/**
-	* Compares this identifier with another by value equality.
-	*
-	* @param id - The identifier to compare against
-	* @returns `true` if both identifiers have the same value
-	*/
-	equals(id: UniqueEntityId): boolean;
-}
-/**
-* Base class for all value objects in the domain.
-*
-* A value object is an object defined entirely by its attributes — it has no
-* identity. Two value objects are considered equal if all their properties
-* are deeply equal, regardless of reference.
-*
-* Value objects should be immutable. Avoid mutating `props` directly;
-* instead, create a new instance with the updated values.
-*
-* All value objects must implement a static `create` factory method to
-* encapsulate construction and validation logic, keeping the constructor
-* protected from external instantiation.
-*
-* @template Props - The shape of the value object's properties
-*
-* @example
-* ```ts
-* interface EmailProps {
-*   value: string
-* }
-*
-* class Email extends ValueObject<EmailProps> {
-*   get value() { return this.props.value }
-*
-*   static create(email: string): Email {
-*     if (!email.includes("@")) {
-*       throw new ValidationError("Invalid email address.")
-*     }
-*
-*     return new Email({ value: email })
-*   }
-* }
-* ```
-*/
-declare abstract class ValueObject<Props> {
-	protected props: Props;
-	protected constructor(props: Props);
-	/**
-	* Compares this value object with another by deep equality of their properties.
-	*
-	* @param other - The value object to compare against
-	* @returns `true` if both value objects have deeply equal properties
-	*/
-	equals(other: ValueObject<Props>): boolean;
-}
-/**
-* Tracks additions and removals of items in a collection, enabling
-* efficient persistence of only what changed.
-*
-* Commonly used inside aggregate roots to manage one-to-many relationships
-* without rewriting the entire collection on every save — only new and
-* removed items are persisted.
-*
-* Subclasses must implement {@link compareItems} to define equality between items.
-*
-* @template T - The type of items in the list
-*
-* @example
-* ```ts
-* class TagList extends WatchedList<Tag> {
-*   compareItems(a: Tag, b: Tag): boolean {
-*     return a.id.equals(b.id)
-*   }
-*
-*   static create(tags: Tag[]): TagList {
-*     return new TagList(tags)
-*   }
-* }
-*
-* const tags = TagList.create([existingTag])
-*
-* tags.add(newTag)      // tracked as new
-* tags.remove(oldTag)   // tracked as removed
-*
-* tags.getNewItems()     // [newTag]
-* tags.getRemovedItems() // [oldTag]
-* ```
-*/
-declare abstract class WatchedList<T> {
-	protected currentItems: T[];
-	protected initial: T[];
-	protected new: T[];
-	protected removed: T[];
-	constructor(initialItems?: T[]);
-	/**
-	* Returns all current items in the list.
-	*/
-	getItems(): T[];
-	/**
-	* Returns items that were added since the list was created.
-	*/
-	getNewItems(): T[];
-	/**
-	* Returns items that were removed since the list was created.
-	*/
-	getRemovedItems(): T[];
-	/**
-	* Returns whether the given item exists in the current list.
-	*
-	* @param item - The item to check
-	*/
-	exists(item: T): boolean;
-	/**
-	* Adds an item to the list, tracking it as new if it wasn't in the initial set.
-	* If the item was previously removed, it is restored.
-	*
-	* @param item - The item to add
-	*/
-	add(item: T): void;
-	/**
-	* Removes an item from the list, tracking it as removed if it was in the initial set.
-	*
-	* @param item - The item to remove
-	*/
-	remove(item: T): void;
-	/**
-	* Replaces the entire list with a new set of items, automatically
-	* computing what was added and what was removed.
-	*
-	* @param items - The new set of items
-	*/
-	update(items: T[]): void;
-	private isCurrentItem;
-	private isNewItem;
-	private isRemovedItem;
-	private removeFromNew;
-	private removeFromCurrent;
-	private removeFromRemoved;
-	private wasAddedInitially;
-}
+import { Either, Optional, UniqueEntityId, ValueObject, WatchedList, left, right } from "../shared/chunk-t21213sm.js";
 export { right, left, WatchedList, ValueObject, UniqueEntityId, Optional, Either };

package/dist/core/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{a,b,c as d,d as e}from"../shared/chunk-kybhb7j0.js";import{h as c}from"../shared/chunk-27pwj1j1.js";export{b as right,a as left,e as WatchedList,d as ValueObject,c as UniqueEntityId};
+import{d as a,e as b,f as c,g as d,h as e}from"../shared/chunk-r63mxet1.js";export{b as right,a as left,e as WatchedList,d as ValueObject,c as UniqueEntityId};

package/dist/domain/application/index.d.ts

@@ -1,204 +1,3 @@
-/**
-* Contract for entities that can be created.
-*
-* @template T - The entity type
-*/
-interface Creatable<T> {
-	/**
-	* Persists a new entity for the first time.
-	*
-	* @param entity - The entity to create
-	*/
-	create(entity: T): Promise<void>;
-}
-/**
-* Contract for entities that can be deleted.
-*
-* @template T - The entity type
-*/
-interface Deletable<T> {
-	/**
-	* Deletes an entity from the repository.
-	*
-	* @param entity - The entity to delete
-	*/
-	delete(entity: T): Promise<void>;
-}
-/**
-* Contract for entities that can be retrieved by their unique identifier.
-*
-* @template T - The entity type
-*/
-interface Findable<T> {
-	/**
-	* Finds an entity by its unique identifier.
-	*
-	* @param id - The unique identifier of the entity
-	* @returns The entity if found, `null` otherwise
-	*/
-	findById(id: string): Promise<T | null>;
-}
-/**
-* Contract for entities that can be persisted.
-*
-* @template T - The entity type
-*/
-interface Saveable<T> {
-	/**
-	* Persists an existing entity.
-	*
-	* @param entity - The entity to save
-	*/
-	save(entity: T): Promise<void>;
-}
-/**
-* Full CRUD repository contract, composing all segregated interfaces.
-*
-* Use this when the repository needs to support all operations. For more
-* constrained repositories, prefer composing only the interfaces you need.
-*
-* @template T - The entity type
-*
-* @example
-* ```ts
-* // full CRUD
-* interface UserRepository extends Repository<User> {
-*   findByEmail(email: string): Promise<User | null>
-* }
-*
-* // read-only
-* interface ReportRepository extends Findable<Report> {
-*   findByPeriod(start: Date, end: Date): Promise<Report[]>
-* }
-*
-* // append-only
-* interface AuditRepository extends Creatable<AuditLog> {}
-* ```
-*/
-interface Repository<T> extends Findable<T>, Saveable<T>, Creatable<T>, Deletable<T> {}
-/**
-* Base contract for all use case errors.
-*
-* Implement this interface to define semantic, domain-aware errors
-* that can be returned as the left side of an {@link Either}.
-*
-* @example
-* ```ts
-* class UserNotFoundError implements UseCaseError {
-*   message = "User not found."
-* }
-*
-* type FindUserResult = Either<UserNotFoundError, User>
-* ```
-*/
-interface UseCaseError {
-	message: string;
-}
-/**
-* Represents the left side of an {@link Either} — conventionally used for
-* failure or error values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Left<
-	L,
-	R
-> {
-	readonly value: L;
-	constructor(value: L);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* Represents the right side of an {@link Either} — conventionally used for
-* success values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Right<
-	L,
-	R
-> {
-	readonly value: R;
-	constructor(value: R);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* A discriminated union that represents a value of one of two possible types.
-*
-* Commonly used as a type-safe alternative to throwing exceptions — the left
-* side carries an error, and the right side carries a success value.
-*
-* Use the {@link left} and {@link right} helper functions to construct values,
-* and `isLeft()` / `isRight()` to narrow the type.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*
-* @example
-* ```ts
-* type FindUserResult = Either<NotFoundError, User>
-*
-* function findUser(id: string): FindUserResult {
-*   const user = db.find(id)
-*   if (!user) return left(new NotFoundError("User", id))
-*   return right(user)
-* }
-*
-* const result = findUser("123")
-*
-* if (result.isLeft()) {
-*   console.error(result.value) // NotFoundError
-* } else {
-*   console.log(result.value)   // User
-* }
-* ```
-*/
-type Either<
-	L,
-	R
-> = Left<L, R> | Right<L, R>;
-/**
-* Represents the expected output shape of any use case.
-* Always an {@link Either} — left for errors, right for success.
-*/
-type UseCaseOutput = Either<UseCaseError | never, unknown | null>;
-/**
-* Base contract for all application use cases.
-*
-* A use case orchestrates domain logic for a single application operation.
-* It receives a typed input, interacts with the domain, and returns an
-* {@link Either} — never throwing exceptions directly.
-*
-* The left side carries a {@link UseCaseError} on failure.
-* The right side carries the success value.
-*
-* @template Input - The shape of the data required to execute the use case
-* @template Output - The expected {@link Either} output, constrained to {@link UseCaseOutput}
-*
-* @example
-* ```ts
-* type Input = { userId: string }
-* type Output = Either<UserNotFoundError, User>
-*
-* class GetUserUseCase implements UseCase<Input, Output> {
-*   constructor(private userRepository: UserRepository) {}
-*
-*   async execute({ userId }: Input): Promise<Output> {
-*     const user = await this.userRepository.findById(userId)
-*     if (!user) return left(new UserNotFoundError(userId))
-*     return right(user)
-*   }
-* }
-* ```
-*/
-interface UseCase<
-	Input,
-	Output extends UseCaseOutput
-> {
-	execute(input: Input): Promise<Output>;
-}
+import { Creatable, Deletable, Findable, Repository, Saveable, UseCase, UseCaseError } from "../../shared/chunk-txbqwwkc.js";
+import "../../shared/chunk-t21213sm.js";
 export { UseCaseError, UseCase, Saveable, Repository, Findable, Deletable, Creatable };