gof-patterns 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Tellez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# gof-patterns
+
+The [Gang of Four catalog](https://refactoring.guru/design-patterns/catalog) as tiny, typed
+helpers. You write the domain logic; the pattern plumbing is already done.
+
+Zero dependencies. ESM. ~6 kB packed.
+
+```bash
+npm i gof-patterns
+```
+
+```ts
+import { stateMachine, chain, singleton } from 'gof-patterns';
+
+const order = stateMachine({
+  initial: 'draft',
+  states: { draft: { pay: 'paid' }, paid: { ship: 'sent' }, sent: {} },
+});
+order.send('pay'); // 'paid'
+order.send('pay'); // throws: "pay" is not allowed in "sent"
+```
+
+## When would I use this?
+
+[**How to use it, and when**](https://github.com/Andrew-Tellez/patterns/blob/main/USE-CASES.md) walks through ten situations from real
+code — a webhook with several payload shapes, an order that must not skip steps, a flaky
+provider that needs retries — and says which helper each one calls for.
+
+## The catalog
+
+### Creational
+
+| Pattern | Helper |
+| --- | --- |
+| Singleton | `singleton(factory)` — one lazy instance, `.reset()` for tests |
+| Factory Method | `registry()` — `register(key, creator)` / `create(key, ...args)` |
+| Abstract Factory | `registry()` — one registry per family |
+| Builder | `builder<T>(defaults?, build?)` — fluent setters, no class |
+| Prototype | `clone(value)` — thin alias for `structuredClone` |
+
+### Structural
+
+| Pattern | Helper |
+| --- | --- |
+| Adapter | `adapt(source, methods)` |
+| Decorator | `decorate(fn, ...wrappers)` — retry/cache/log layers |
+| Composite | `composite(value, children?)` — `add`, `walk()`, `sum()` |
+| Flyweight | `flyweight(factory, key?)` — shared instances per key |
+| Proxy | `lazy(loader)` — real object built on first access |
+| Facade | *no helper* — an object that delegates. Just write it. |
+| Bridge | *no helper* — pass the implementation in. Just write it. |
+
+### Behavioral
+
+| Pattern | Helper |
+| --- | --- |
+| Chain of Responsibility | `chain(handlers, fallback?)` — `(req, next) => res`, sync or async |
+| Command | `commandBus()` — `run`, `undo`, `redo` |
+| Observer | `subject<T>()` — `subscribe` returns the unsubscribe |
+| Mediator | `mediator<Events>()` — typed `on` / `emit` hub |
+| Memento | `history(initial, { limit?, snapshot? })` — undo/redo |
+| State | `stateMachine({ initial, states })` |
+| Strategy | `registry()` — swap the registered implementation |
+| Visitor | `visitor(visitors, fallback?)` — dispatch on `node.type` |
+| Template Method | `template(defaults, skeleton)` — override single steps |
+| Iterator | *no helper* — generators and `for...of` are in the language |
+
+Five entries have no helper on purpose: a wrapper there would be more code to read
+than the pattern it hides. The table says what to write instead.
+
+## Examples
+
+**Decorator** — layers, outermost first:
+
+```ts
+const withRetry = (n: number) => (next) => async (...args) => {
+  for (let i = 0; ; i++) {
+    try { return await next(...args); } catch (e) { if (i >= n) throw e; }
+  }
+};
+const fetchUser = decorate(rawFetchUser, withLog, withRetry(3));
+```
+
+**Chain of Responsibility** — first handler that answers wins:
+
+```ts
+const route = chain<Ticket, string>(
+  [(t, next) => (t.level === 1 ? 'bot' : next()),
+   (t, next) => (t.paid ? 'human' : next())],
+  () => 'queue',
+);
+```
+
+**Memento** — undo over snapshots (pass `snapshot` if you mutate state in place):
+
+```ts
+const h = history({ text: '' }, { limit: 50, snapshot: structuredClone });
+h.save({ text: 'hi' });
+h.undo(); // { text: '' }
+```
+
+## Development
+
+```bash
+npm test          # node --test, no framework
+npm run build     # tsc
+```
+
+## License
+
+MIT

package/dist/behavioral.d.ts

@@ -0,0 +1,147 @@
+/** Behavioral patterns. */
+/**
+ * Chain of Responsibility — each handler either answers or calls `next()`.
+ * Works for sync and async (`Res` can be a Promise).
+ *
+ * ```ts
+ * const support = chain<Ticket, string>(
+ *   [(t, next) => (t.level === 1 ? 'bot' : next()), (t, next) => (t.paid ? 'human' : next())],
+ *   () => 'queue',
+ * );
+ * ```
+ */
+export type Handler<Req, Res> = (request: Req, next: () => Res) => Res;
+export declare function chain<Req, Res>(handlers: Handler<Req, Res>[], fallback?: (request: Req) => Res): (request: Req) => Res;
+/**
+ * Command — undoable operations with history.
+ *
+ * ```ts
+ * const bus = commandBus();
+ * bus.run({ do: () => doc.push('a'), undo: () => doc.pop() });
+ * bus.undo();
+ * bus.redo();
+ * ```
+ * A command without `undo` clears the redo stack and cannot be undone.
+ */
+export type Command<T = unknown> = {
+    do(): T;
+    undo?(): void;
+};
+export type CommandBus = {
+    run<T>(command: Command<T>): T;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+};
+export declare function commandBus(): CommandBus;
+/**
+ * Observer — one typed channel. `subscribe` returns the unsubscribe function.
+ *
+ * ```ts
+ * const priceChanged = subject<number>();
+ * const off = priceChanged.subscribe((p) => render(p));
+ * priceChanged.emit(9.99);
+ * off();
+ * ```
+ */
+export type Subject<T> = {
+    subscribe(listener: (value: T) => void): () => void;
+    emit(value: T): void;
+    size(): number;
+};
+export declare function subject<T>(): Subject<T>;
+/**
+ * Mediator — components talk to a typed hub, never to each other.
+ *
+ * ```ts
+ * const hub = mediator<{ login: { id: string }; logout: void }>();
+ * hub.on('login', ({ id }) => track(id));
+ * hub.emit('login', { id: 'u1' });
+ * ```
+ */
+export type Mediator<E extends Record<string, unknown>> = {
+    on<K extends keyof E>(event: K, listener: (payload: E[K]) => void): () => void;
+    emit<K extends keyof E>(event: K, payload: E[K]): void;
+};
+export declare function mediator<E extends Record<string, unknown>>(): Mediator<E>;
+/**
+ * Memento — undo/redo over snapshots of state.
+ *
+ * ```ts
+ * const h = history({ text: '' });
+ * h.save({ text: 'hi' });
+ * h.undo(); // { text: '' }
+ * ```
+ * Snapshots are stored by reference — pass a copy, or a `snapshot` function,
+ * if the state object is mutated in place.
+ */
+export type History<T> = {
+    current(): T;
+    save(state: T): void;
+    undo(): T | undefined;
+    redo(): T | undefined;
+    canUndo(): boolean;
+    canRedo(): boolean;
+};
+export declare function history<T>(initial: T, options?: {
+    limit?: number;
+    snapshot?: (state: T) => T;
+}): History<T>;
+/**
+ * State — a finite state machine from a transition table.
+ *
+ * ```ts
+ * const order = stateMachine({
+ *   initial: 'draft',
+ *   states: { draft: { pay: 'paid' }, paid: { ship: 'sent' }, sent: {} },
+ * });
+ * order.send('pay');  // 'paid'
+ * order.can('ship');  // true
+ * ```
+ * A transition value may be a target state or `(payload) => target`.
+ */
+export type Transitions<S extends string, E extends string> = Record<S, Partial<Record<E, S | ((payload: unknown) => S)>>>;
+export type StateMachine<S extends string, E extends string> = {
+    state(): S;
+    can(event: E): boolean;
+    /** Returns the new state. Throws on an event the current state does not allow. */
+    send(event: E, payload?: unknown): S;
+    onChange(listener: (change: {
+        from: S;
+        to: S;
+        event: E;
+    }) => void): () => void;
+};
+export declare function stateMachine<S extends string, E extends string>(config: {
+    initial: S;
+    states: Transitions<S, E>;
+}): StateMachine<S, E>;
+/**
+ * Visitor — dispatch on a node's kind instead of a switch scattered everywhere.
+ *
+ * ```ts
+ * const area = visitor<Shape, number>({
+ *   circle: (c) => Math.PI * c.r ** 2,
+ *   square: (s) => s.side ** 2,
+ * });
+ * area({ type: 'circle', r: 1 });
+ * ```
+ */
+export declare function visitor<N extends {
+    type: string;
+}, R>(visitors: {
+    [K in N['type']]?: (node: Extract<N, {
+        type: K;
+    }>) => R;
+}, fallback?: (node: N) => R): (node: N) => R;
+/**
+ * Template Method — a fixed skeleton with replaceable steps.
+ *
+ * ```ts
+ * const mine = template({ read: () => csv(), parse: (s: string) => s.split(',') },
+ *   (hooks) => hooks.parse(hooks.read()));
+ * mine({ read: () => 'a,b' })(); // ['a', 'b']
+ * ```
+ */
+export declare function template<H extends Record<string, (...args: never[]) => unknown>, A extends unknown[], R>(defaults: H, skeleton: (hooks: H, ...args: A) => R): (overrides?: Partial<H>) => (...args: A) => R;

package/dist/behavioral.js

@@ -0,0 +1,156 @@
+/** Behavioral patterns. */
+export function chain(handlers, fallback) {
+    return (request) => {
+        const step = (i) => {
+            const handler = handlers[i];
+            if (!handler) {
+                if (!fallback)
+                    throw new Error('chain: no handler answered and no fallback was given');
+                return fallback(request);
+            }
+            return handler(request, () => step(i + 1));
+        };
+        return step(0);
+    };
+}
+export function commandBus() {
+    const done = [];
+    let undone = [];
+    return {
+        run(command) {
+            const result = command.do();
+            undone = [];
+            if (command.undo)
+                done.push(command);
+            return result;
+        },
+        undo() {
+            const command = done.pop();
+            if (!command)
+                return false;
+            command.undo?.();
+            undone.push(command);
+            return true;
+        },
+        redo() {
+            const command = undone.pop();
+            if (!command)
+                return false;
+            command.do();
+            done.push(command);
+            return true;
+        },
+        canUndo: () => done.length > 0,
+        canRedo: () => undone.length > 0,
+    };
+}
+export function subject() {
+    const listeners = new Set();
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => void listeners.delete(listener);
+        },
+        // Iterate a copy: a listener may unsubscribe during emit.
+        emit: (value) => [...listeners].forEach((listener) => listener(value)),
+        size: () => listeners.size,
+    };
+}
+export function mediator() {
+    const channels = new Map();
+    const channel = (event) => {
+        let existing = channels.get(event);
+        if (!existing)
+            channels.set(event, (existing = subject()));
+        return existing;
+    };
+    return {
+        on: (event, listener) => channel(event).subscribe(listener),
+        emit: (event, payload) => channel(event).emit(payload),
+    };
+}
+export function history(initial, options = {}) {
+    const { limit = Infinity, snapshot = (state) => state } = options;
+    const past = [];
+    const future = [];
+    let present = snapshot(initial);
+    return {
+        current: () => present,
+        save(state) {
+            past.push(present);
+            if (past.length > limit)
+                past.shift();
+            future.length = 0;
+            present = snapshot(state);
+        },
+        undo() {
+            if (!past.length)
+                return undefined;
+            future.push(present);
+            return (present = past.pop());
+        },
+        redo() {
+            if (!future.length)
+                return undefined;
+            past.push(present);
+            return (present = future.pop());
+        },
+        canUndo: () => past.length > 0,
+        canRedo: () => future.length > 0,
+    };
+}
+export function stateMachine(config) {
+    let state = config.initial;
+    const changes = subject();
+    const target = (event) => config.states[state]?.[event];
+    return {
+        state: () => state,
+        can: (event) => target(event) !== undefined,
+        send(event, payload) {
+            const to = target(event);
+            if (to === undefined)
+                throw new Error(`stateMachine: "${event}" is not allowed in "${state}"`);
+            const from = state;
+            // S extends string, so a function value is always the dynamic-target form.
+            state = typeof to === 'function' ? to(payload) : to;
+            changes.emit({ from, to: state, event });
+            return state;
+        },
+        onChange: (listener) => changes.subscribe(listener),
+    };
+}
+/**
+ * Visitor — dispatch on a node's kind instead of a switch scattered everywhere.
+ *
+ * ```ts
+ * const area = visitor<Shape, number>({
+ *   circle: (c) => Math.PI * c.r ** 2,
+ *   square: (s) => s.side ** 2,
+ * });
+ * area({ type: 'circle', r: 1 });
+ * ```
+ */
+export function visitor(visitors, fallback) {
+    return (node) => {
+        const visit = visitors[node.type];
+        if (visit)
+            return visit(node);
+        if (fallback)
+            return fallback(node);
+        throw new Error(`visitor: no visitor for "${node.type}"`);
+    };
+}
+/**
+ * Template Method — a fixed skeleton with replaceable steps.
+ *
+ * ```ts
+ * const mine = template({ read: () => csv(), parse: (s: string) => s.split(',') },
+ *   (hooks) => hooks.parse(hooks.read()));
+ * mine({ read: () => 'a,b' })(); // ['a', 'b']
+ * ```
+ */
+export function template(defaults, skeleton) {
+    return (overrides) => (...args) => skeleton({ ...defaults, ...overrides }, ...args);
+}
+// ponytail: Iterator is a generator function plus `for...of` — already in the
+// language, so there is no helper for it.

package/dist/creational.d.ts

@@ -0,0 +1,44 @@
+/** Creational patterns. */
+/**
+ * Singleton — one lazily created instance, shared.
+ *
+ * ```ts
+ * const db = singleton(() => connect(url));
+ * db() === db(); // same instance
+ * db.reset();    // drop it (tests)
+ * ```
+ */
+export declare function singleton<T>(factory: () => T): (() => T) & {
+    reset(): void;
+};
+/**
+ * Factory Method / Abstract Factory / Strategy — a registry keyed by name.
+ *
+ * ```ts
+ * const shapes = registry<{ circle: (r: number) => Shape }>();
+ * shapes.register('circle', (r) => new Circle(r));
+ * shapes.create('circle', 2);
+ * ```
+ */
+export type Registry<M extends Record<string, (...args: never[]) => unknown>> = {
+    register<K extends keyof M>(key: K, creator: M[K]): void;
+    create<K extends keyof M>(key: K, ...args: Parameters<M[K]>): ReturnType<M[K]>;
+    has(key: PropertyKey): boolean;
+    keys(): (keyof M)[];
+};
+export declare function registry<M extends Record<string, (...args: never[]) => unknown>>(initial?: Partial<M>): Registry<M>;
+/**
+ * Builder — fluent setters for a plain object, no class boilerplate.
+ *
+ * ```ts
+ * const pizza = builder<Pizza>({ size: 'M' }).cheese(true).size('L').build();
+ * ```
+ * Pass `build` to validate or construct something else at the end.
+ */
+export type Builder<T, R = T> = {
+    [K in keyof T]-?: (value: T[K]) => Builder<T, R>;
+} & {
+    build(): R;
+};
+export declare function builder<T extends object, R = T>(defaults?: Partial<T>, build?: (draft: Partial<T>) => R): Builder<T, R>;
+export declare const clone: <T>(value: T) => T;

package/dist/creational.js

@@ -0,0 +1,57 @@
+/** Creational patterns. */
+/**
+ * Singleton — one lazily created instance, shared.
+ *
+ * ```ts
+ * const db = singleton(() => connect(url));
+ * db() === db(); // same instance
+ * db.reset();    // drop it (tests)
+ * ```
+ */
+export function singleton(factory) {
+    let value;
+    let made = false;
+    const get = () => {
+        if (!made) {
+            value = factory();
+            made = true;
+        }
+        return value;
+    };
+    get.reset = () => {
+        made = false;
+        value = undefined;
+    };
+    return get;
+}
+export function registry(initial) {
+    const map = new Map(Object.entries(initial ?? {}));
+    return {
+        register: (key, creator) => void map.set(key, creator),
+        create: (key, ...args) => {
+            const creator = map.get(key);
+            if (!creator)
+                throw new Error(`registry: nothing registered for "${String(key)}"`);
+            return creator(...args);
+        },
+        has: (key) => map.has(key),
+        keys: () => [...map.keys()],
+    };
+}
+export function builder(defaults, build) {
+    const draft = { ...defaults };
+    const proxy = new Proxy({}, {
+        get(_t, prop) {
+            if (prop === 'build')
+                return () => (build ? build(draft) : { ...draft });
+            return (value) => {
+                draft[prop] = value;
+                return proxy;
+            };
+        },
+    });
+    return proxy;
+}
+// ponytail: Prototype is `structuredClone` in the stdlib. Re-exported so the
+// catalog is complete; it does not copy functions or class prototypes.
+export const clone = (value) => structuredClone(value);

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * gof-patterns — the GoF catalog as tiny, typed helpers.
+ * MIT. https://refactoring.guru/design-patterns/catalog
+ */
+export * from './creational.ts';
+export * from './structural.ts';
+export * from './behavioral.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * gof-patterns — the GoF catalog as tiny, typed helpers.
+ * MIT. https://refactoring.guru/design-patterns/catalog
+ */
+export * from "./creational.js";
+export * from "./structural.js";
+export * from "./behavioral.js";

package/dist/structural.d.ts

@@ -0,0 +1,62 @@
+/** Structural patterns. */
+/**
+ * Adapter — expose an incompatible object through the interface you want.
+ *
+ * ```ts
+ * const logger = adapt(winston, { log: (w) => (m: string) => w.info(m) });
+ * ```
+ */
+export declare function adapt<S, A extends Record<string, (source: S) => unknown>>(source: S, methods: A): {
+    [K in keyof A]: ReturnType<A[K]>;
+};
+/**
+ * Decorator — wrap a function in layers (retry, cache, log) without touching it.
+ * Applied left to right: the first wrapper is the outermost.
+ *
+ * ```ts
+ * const fetchUser = decorate(rawFetchUser, withLog, withRetry(3));
+ * ```
+ */
+export type Wrapper<F extends (...args: never[]) => unknown> = (next: F) => F;
+export declare function decorate<F extends (...args: never[]) => unknown>(fn: F, ...wrappers: Wrapper<F>[]): F;
+/**
+ * Composite — treat a tree of nodes like a single node.
+ *
+ * ```ts
+ * const box = composite({ price: 10 });
+ * box.add(composite({ price: 5 }));
+ * box.sum((n) => n.price); // 15
+ * ```
+ */
+export type Composite<T> = {
+    readonly value: T;
+    readonly children: Composite<T>[];
+    add(...children: Composite<T>[]): Composite<T>;
+    remove(child: Composite<T>): boolean;
+    /** Depth-first, self first. */
+    walk(): Generator<Composite<T>>;
+    sum(of: (value: T) => number): number;
+};
+export declare function composite<T>(value: T, children?: Composite<T>[]): Composite<T>;
+/**
+ * Flyweight — share immutable instances instead of re-creating them.
+ *
+ * ```ts
+ * const treeType = flyweight((name: string, color: string) => ({ name, color }));
+ * treeType('oak', 'green') === treeType('oak', 'green'); // true
+ * ```
+ * Default key is `JSON.stringify(args)`; pass `key` for anything richer.
+ */
+export declare function flyweight<A extends unknown[], T>(factory: (...args: A) => T, key?: (...args: A) => string): ((...args: A) => T) & {
+    size(): number;
+    clear(): void;
+};
+/**
+ * Proxy (virtual) — build the real object on first property access.
+ *
+ * ```ts
+ * const heavy = lazy(() => loadHugeThing()); // nothing loaded yet
+ * heavy.query('x');                          // loads now, once
+ * ```
+ */
+export declare function lazy<T extends object>(loader: () => T): T;

package/dist/structural.js

@@ -0,0 +1,89 @@
+/** Structural patterns. */
+/**
+ * Adapter — expose an incompatible object through the interface you want.
+ *
+ * ```ts
+ * const logger = adapt(winston, { log: (w) => (m: string) => w.info(m) });
+ * ```
+ */
+export function adapt(source, methods) {
+    const out = {};
+    for (const key of Object.keys(methods)) {
+        out[key] = methods[key](source);
+    }
+    return out;
+}
+export function decorate(fn, ...wrappers) {
+    return wrappers.reduceRight((next, wrap) => wrap(next), fn);
+}
+export function composite(value, children = []) {
+    const node = {
+        value,
+        children,
+        add(...kids) {
+            children.push(...kids);
+            return node;
+        },
+        remove(child) {
+            const i = children.indexOf(child);
+            if (i < 0)
+                return false;
+            children.splice(i, 1);
+            return true;
+        },
+        *walk() {
+            yield node;
+            for (const child of children)
+                yield* child.walk();
+        },
+        sum(of) {
+            let total = 0;
+            for (const n of node.walk())
+                total += of(n.value);
+            return total;
+        },
+    };
+    return node;
+}
+/**
+ * Flyweight — share immutable instances instead of re-creating them.
+ *
+ * ```ts
+ * const treeType = flyweight((name: string, color: string) => ({ name, color }));
+ * treeType('oak', 'green') === treeType('oak', 'green'); // true
+ * ```
+ * Default key is `JSON.stringify(args)`; pass `key` for anything richer.
+ */
+export function flyweight(factory, key = (...args) => JSON.stringify(args)) {
+    const cache = new Map();
+    const get = (...args) => {
+        const k = key(...args);
+        if (!cache.has(k))
+            cache.set(k, factory(...args));
+        return cache.get(k);
+    };
+    get.size = () => cache.size;
+    get.clear = () => cache.clear();
+    return get;
+}
+/**
+ * Proxy (virtual) — build the real object on first property access.
+ *
+ * ```ts
+ * const heavy = lazy(() => loadHugeThing()); // nothing loaded yet
+ * heavy.query('x');                          // loads now, once
+ * ```
+ */
+export function lazy(loader) {
+    let target;
+    const get = () => (target ??= loader());
+    return new Proxy({}, {
+        get: (_t, prop, receiver) => Reflect.get(get(), prop, receiver),
+        set: (_t, prop, value) => Reflect.set(get(), prop, value),
+        has: (_t, prop) => Reflect.has(get(), prop),
+        ownKeys: () => Reflect.ownKeys(get()),
+        getOwnPropertyDescriptor: (_t, prop) => Reflect.getOwnPropertyDescriptor(get(), prop),
+    });
+}
+// ponytail: Facade and Bridge are plain composition — an object or class that
+// delegates. No runtime helper can make that shorter than writing it. See README.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "gof-patterns",
+  "version": "0.1.0",
+  "description": "GoF design patterns as tiny, typed helpers. You supply the domain logic; the pattern plumbing is done.",
+  "license": "MIT",
+  "author": "Andrew Tellez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Andrew-Tellez/patterns.git",
+    "directory": "packages/ts"
+  },
+  "homepage": "https://github.com/Andrew-Tellez/patterns#readme",
+  "keywords": [
+    "design-patterns",
+    "gof",
+    "typescript",
+    "singleton",
+    "builder",
+    "state-machine",
+    "observer",
+    "strategy"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "node --test src/*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}