@fougere/core 0.2.0-alpha.1 → 0.3.0-alpha.0

package/dist/prefab/repository.d.ts

@@ -0,0 +1,104 @@
+import { type EntityConstructor } from '@fougere/schema';
+import type { EntityOrm } from '../orm.js';
+/**
+ * Repository(…entities) — who owns an entity's storage, and where its questions are named.
+ *
+ * **The arity decides**, which is the second reading of what `orm.ts` already states for
+ * `EntityOrm` against `Together`: the arity of the unit is the whole distinction.
+ *
+ * ONE entity — the repository IS that entity's storage, with your methods added. The port's
+ * thirteen gestures are forwarded, so a handler reads `this.posts.list()` whether or not
+ * anyone wrote the file, and a named question sits beside them:
+ *
+ * ```ts
+ * // repositories/PostRepository.ts
+ * export default class PostRepository extends Repository(Post) {
+ *   published() {
+ *     return this.list({ where: { status: 'published' }, orderBy: 'publishedAt', order: 'desc' });
+ *   }
+ * }
+ * ```
+ *
+ * TWO OR MORE — an aggregate. It owns them: nothing else in the app is handed their
+ * storage, and no gesture is forwarded (which entity would `create` write to?), so the only
+ * way in is a method this class names. That is what lets a rule spanning two tables exist:
+ * it is ordinary TypeScript inside the method that does the writing.
+ *
+ * ```ts
+ * // repositories/CommandeRepository.ts
+ * export default class CommandeRepository extends Repository(Commande, Stock) {
+ *   avecLignes(id: string) {
+ *     const [commandes, stock] = this.orms;
+ *     …
+ *   }
+ * }
+ * ```
+ *
+ * `this.orms` is protected, because the whole point is that the storage stops at this file.
+ * `protected` is erased at runtime, like `abstract` on a port: a compile-time guarantee, not
+ * a barrier. The same bargain, already accepted.
+ *
+ * **The boundary is not the unit of work.** An aggregate says the rules of these entities
+ * hold together; a frame says these writes land together, and the two lists coincide only
+ * often. Deriving the frame from the membership would make a read-only aggregate carry one
+ * — refusals included, and `registerFrames` refuses without storage or over `remotes:` —
+ * and would put `Together<[Commande, Stock], [StockMirror]>` out of reach forever. So a
+ * frame is ASKED FOR here as anywhere else, which is what makes it declared:
+ *
+ * ```ts
+ * constructor(commandes: CommandeOrm, stock: StockOrm, private frame: Together<[Commande, Stock]>) {
+ *   super(commandes, stock);
+ * }
+ * ```
+ *
+ * The ORM words come back in that line, and only there: this class IS the holder, which is
+ * the one case `boot/ownership.ts` lets name the storage it was built on.
+ *
+ * A repository is NOT a door: it has no façade, so nothing here is reachable from the wire.
+ */
+/**
+ * The shape a repository of ONE entity has — the port itself, plus whatever the subclass
+ * names on top. Written by an author who has not written the file: `RepositoryOf<Post>` is
+ * to `PostRepository` what `EntityOrm<Post>` is to `PostOrm`, one spelling of one key, and
+ * `depKeyOf` reads both.
+ */
+export type RepositoryOf<T> = EntityOrm<T>;
+/** The single-entity form: the port, plus whatever the subclass names. */
+export interface RepositoryConstructor<T> {
+    new (orm: EntityOrm<T>): EntityOrm<T>;
+    readonly __entity: unknown;
+}
+/**
+ * What an aggregate's subclass sees: the storage of the members it owns, in declared order,
+ * and `protected` — the storage stops at that file, which is the whole mechanism.
+ *
+ * A class and not an interface, because `protected` cannot be spelled in one. Ambient: the
+ * value it describes is fabricated by `many()` for an arity only known at the call.
+ */
+declare abstract class AggregateShape<E extends readonly EntityConstructor[]> {
+    protected orms: {
+        [K in keyof E]: EntityOrm<InstanceType<E[K]>>;
+    };
+}
+/** The tuple an aggregate holds — the readable form of {@link AggregateShape}'s member. */
+export type AggregateOf<E extends readonly EntityConstructor[]> = {
+    [K in keyof E]: EntityOrm<InstanceType<E[K]>>;
+};
+export type AggregateConstructor<E extends readonly EntityConstructor[]> = (new (...orms: unknown[]) => AggregateShape<E>) & {
+    readonly __entity: unknown;
+    /** The entities this class owns. Present from two on — an owner of one owns nothing. */
+    readonly __owns: E;
+};
+export declare function Repository<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>>;
+export declare function Repository<E extends readonly [EntityConstructor, EntityConstructor, ...EntityConstructor[]]>(...entities: E): AggregateConstructor<E>;
+/** Container key of an entity's repository — 'reading' → 'ReadingRepository'. */
+export declare function repositoryKeyOf(entity: string): string;
+/**
+ * The entities a class owns — empty for anything that is not an aggregate.
+ *
+ * Read from the mark rather than from the constructor, for the reason `Crud.__ops` exists:
+ * the AST scan is workspace-only, so an installed prefab resolves to nothing.
+ */
+export declare function ownedBy(ctor: unknown): readonly EntityConstructor[];
+export {};
+//# sourceMappingURL=repository.d.ts.map

package/dist/prefab/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/prefab/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,WAAW,CAAC;AAGlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;AAE3C,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,KAAK,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,OAAO,CAAC,QAAQ,OAAO,cAAc,CAAC,CAAC,SAAS,SAAS,iBAAiB,EAAE;IAC1E,SAAS,CAAC,IAAI,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;CACnE;AAED,2FAA2F;AAC3F,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,iBAAiB,EAAE,IAC5D;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEpD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,SAAS,iBAAiB,EAAE,IACrE,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG;IAChD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;CACpB,CAAC;AAEJ,wBAAgB,UAAU,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE,CAAC,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3G,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAAC,EAC1G,GAAG,QAAQ,EAAE,CAAC,GACb,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAwD3B,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,iBAAiB,EAAE,CAEnE"}

package/dist/prefab/repository.js

@@ -0,0 +1,62 @@
+import { classNameOf } from '@fougere/schema';
+export function Repository(...entities) {
+    return entities.length === 1 ? one(entities[0]) : many(entities);
+}
+/**
+ * The port forwarded, member by member. Written out rather than proxied: a Proxy would
+ * answer every name including the ones the port does not have, and this file would then
+ * state the surface nowhere. Thirteen lines against one declaration that can be read.
+ */
+function one(entity) {
+    class RepositoryBase {
+        orm;
+        static __entity = entity;
+        constructor(orm) {
+            this.orm = orm;
+        }
+        list(options) { return this.orm.list(options); }
+        findById(id, options) { return this.orm.findById(id, options); }
+        findBy(criteria, options) { return this.orm.findBy(criteria, options); }
+        findAllBy(criteria, options) { return this.orm.findAllBy(criteria, options); }
+        findByKeys(ids, options) { return this.orm.findByKeys(ids, options); }
+        findAllByKeys(field, keys, options) { return this.orm.findAllByKeys(field, keys, options); }
+        create(input, options) { return this.orm.create(input, options); }
+        upsert(input, options) { return this.orm.upsert(input, options); }
+        upsertAll(inputs, options) { return this.orm.upsertAll(inputs, options); }
+        update(id, input, options) { return this.orm.update(id, input, options); }
+        delete(id) { return this.orm.delete(id); }
+        output(schema) { return this.orm.output(schema); }
+        get client() { return this.orm.client; }
+    }
+    return RepositoryBase;
+}
+/**
+ * The aggregate. Its constructor takes the members' storage in the DECLARED order — the
+ * order `toProvider` fills its `deps` with, and the order a subclass hands back to `super()`
+ * when it declares a constructor of its own.
+ */
+function many(entities) {
+    class AggregateBase {
+        static __entity = entities[0];
+        static __owns = entities;
+        orms;
+        constructor(...orms) {
+            this.orms = orms.slice(0, entities.length);
+        }
+    }
+    return AggregateBase;
+}
+/** Container key of an entity's repository — 'reading' → 'ReadingRepository'. */
+export function repositoryKeyOf(entity) {
+    return `${classNameOf(entity)}Repository`;
+}
+/**
+ * The entities a class owns — empty for anything that is not an aggregate.
+ *
+ * Read from the mark rather than from the constructor, for the reason `Crud.__ops` exists:
+ * the AST scan is workspace-only, so an installed prefab resolves to nothing.
+ */
+export function ownedBy(ctor) {
+    return ctor?.__owns ?? [];
+}
+//# sourceMappingURL=repository.js.map

package/dist/prefab/repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.js","sourceRoot":"","sources":["../../src/prefab/repository.ts"],"names":[],"mappings":"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"}

package/dist/scan/Fronds.d.ts

@@ -0,0 +1,45 @@
+import type { SchemaView } from '@fougere/schema';
+import type { EntityEntry, FrondDescriptor } from './frond.js';
+/**
+ * What this app hosts — the scan's answer, with the questions everyone was asking it
+ * by hand.
+ *
+ * The list was a bare array, so every reader re-walked it: "which frond owns this
+ * entity" was spelled four times, "every entity by name" three times as three literal
+ * copies of the same `Map`, and the two inside the boot even carried comments saying so.
+ * A concept nobody can question is a concept everyone rebuilds.
+ *
+ * It IS an array — the same reason `ListResult` is one: twenty call sites iterate,
+ * filter and spread it, and none of them is wrong to. `Symbol.species` is `Array` so a
+ * `.map()` over it answers a plain array rather than something that claims to be a
+ * hosting table and holds strings.
+ */
+export declare class Fronds extends Array<FrondDescriptor> {
+    static get [Symbol.species](): ArrayConstructor;
+    /** What one scan run found. The only gate in — `Array.of` is taken, and named. */
+    static scanned(fronds: readonly FrondDescriptor[]): Fronds;
+    /** The frond that hosts an entity — `undefined` when no loaded frond does. */
+    owner(entity: string): FrondDescriptor | undefined;
+    /** The entity of that name, wherever it was scanned. */
+    entity(name: string): EntityEntry | undefined;
+    /**
+     * Every scanned entity class, by name — across all fronds and never per-frond.
+     *
+     * A fact is announced in one frond and heard in another, so the subscriber's own
+     * frond does not hold the shape it must judge; a `reads:` clause names entities
+     * that belong to neighbours by definition.
+     */
+    schemas(): Map<string, SchemaView>;
+    /** Every scanned entity, sorted. What was FOUND, not what answers. */
+    entityNames(): string[];
+    /**
+     * The names a call may address, sorted — what a NOT_FOUND must print.
+     *
+     * Not `entityNames()`, which is what the scan found: an entity with no handler is
+     * scanned and serves nothing, so the refusal read *"Entity 'indexed' is not hosted
+     * here. Hosted here: indexed."* — naming the very thing it had just refused. A façade
+     * is keyed on a HANDLER's address, and that is what this lists.
+     */
+    servedNames(surface?: string): string[];
+}
+//# sourceMappingURL=Fronds.d.ts.map

package/dist/scan/Fronds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fronds.d.ts","sourceRoot":"","sources":["../../src/scan/Fronds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;GAaG;AACH,qBAAa,MAAO,SAAQ,KAAK,CAAC,eAAe,CAAC;IAChD,WAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAEvD;IAED,kFAAkF;IAClF,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM;IAM1D,8EAA8E;IAC9E,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIlD,wDAAwD;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAQ7C;;;;;;OAMG;IACH,OAAO,IAAI,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IAIlC,sEAAsE;IACtE,WAAW,IAAI,MAAM,EAAE;IAIvB;;;;;;;OAOG;IACH,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;CAKxC"}

package/dist/scan/Fronds.js

@@ -0,0 +1,66 @@
+/**
+ * What this app hosts — the scan's answer, with the questions everyone was asking it
+ * by hand.
+ *
+ * The list was a bare array, so every reader re-walked it: "which frond owns this
+ * entity" was spelled four times, "every entity by name" three times as three literal
+ * copies of the same `Map`, and the two inside the boot even carried comments saying so.
+ * A concept nobody can question is a concept everyone rebuilds.
+ *
+ * It IS an array — the same reason `ListResult` is one: twenty call sites iterate,
+ * filter and spread it, and none of them is wrong to. `Symbol.species` is `Array` so a
+ * `.map()` over it answers a plain array rather than something that claims to be a
+ * hosting table and holds strings.
+ */
+export class Fronds extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    /** What one scan run found. The only gate in — `Array.of` is taken, and named. */
+    static scanned(fronds) {
+        const held = new Fronds();
+        held.push(...fronds);
+        return held;
+    }
+    /** The frond that hosts an entity — `undefined` when no loaded frond does. */
+    owner(entity) {
+        return this.find((frond) => frond.entities.some((e) => e.name === entity));
+    }
+    /** The entity of that name, wherever it was scanned. */
+    entity(name) {
+        for (const frond of this) {
+            const found = frond.entities.find((e) => e.name === name);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    /**
+     * Every scanned entity class, by name — across all fronds and never per-frond.
+     *
+     * A fact is announced in one frond and heard in another, so the subscriber's own
+     * frond does not hold the shape it must judge; a `reads:` clause names entities
+     * that belong to neighbours by definition.
+     */
+    schemas() {
+        return new Map(this.flatMap((frond) => frond.entities.map((e) => [e.name, e.entityClass])));
+    }
+    /** Every scanned entity, sorted. What was FOUND, not what answers. */
+    entityNames() {
+        return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
+    }
+    /**
+     * The names a call may address, sorted — what a NOT_FOUND must print.
+     *
+     * Not `entityNames()`, which is what the scan found: an entity with no handler is
+     * scanned and serves nothing, so the refusal read *"Entity 'indexed' is not hosted
+     * here. Hosted here: indexed."* — naming the very thing it had just refused. A façade
+     * is keyed on a HANDLER's address, and that is what this lists.
+     */
+    servedNames(surface) {
+        return this.flatMap((frond) => frond.handlers
+            .filter((handler) => (handler.surface ?? undefined) === surface)
+            .map((handler) => handler.address)).sort();
+    }
+}
+//# sourceMappingURL=Fronds.js.map

package/dist/scan/Fronds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fronds.js","sourceRoot":"","sources":["../../src/scan/Fronds.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,MAAO,SAAQ,KAAsB;IAChD,MAAM,KAAc,CAAC,MAAM,CAAC,OAAO,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kFAAkF;IAClF,MAAM,CAAC,OAAO,CAAC,MAAkC;QAC/C,MAAM,IAAI,GAAG,IAAI,MAAM,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,MAAc;QAClB,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED,wDAAwD;IACxD,MAAM,CAAC,IAAY;QACjB,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,CAAC;YACzB,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAC1D,IAAI,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC1B,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACH,OAAO;QACL,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAU,CAAC,CAAC,CAAC,CAAC;IACvG,CAAC;IAED,sEAAsE;IACtE,WAAW;QACT,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3E,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,OAAgB;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ;aAC1C,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,IAAI,SAAS,CAAC,KAAK,OAAO,CAAC;aAC/D,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/C,CAAC;CACF"}

package/dist/scan/conventions.d.ts

@@ -0,0 +1,74 @@
+export interface Conventions {
+    /**
+     * The scope a frond's package name carries — `@fronds/blog`.
+     *
+     * A real package name, not only an alias: the CLI writes it as `name` in a scaffolded
+     * frond and as a `workspace:*` dependency in the app that consumes it.
+     */
+    scope: string;
+    /** The directory holding fronds, below the project root. */
+    fronds: string;
+    /** Directory per role. The role is the key; the name on disk is the value. */
+    dirs: {
+        entities: string;
+        handlers: string;
+        services: string;
+        repositories: string;
+        presenters: string;
+        collectors: string;
+        seeds: string;
+        /** What its shapes used to be — written by `fougere freeze`, replayed by `migrate`. */
+        versions: string;
+    };
+}
+/**
+ * What a project means when it declares nothing — the convention itself.
+ *
+ * `@fronds` and not `@frond`: the npm org for the singular belongs to someone else, and a
+ * scope is a name that must be ownable.
+ */
+export declare const DEFAULT_CONVENTIONS: Conventions;
+/** What a `fougere.config.ts` may state: only the names that differ. */
+export type ConventionsInput = {
+    scope?: string;
+    fronds?: string;
+    dirs?: Partial<Conventions['dirs']>;
+};
+/**
+ * The convention, with a project's exceptions folded in.
+ *
+ * Merged one level into `dirs` so renaming one directory does not require restating the
+ * other six — the same reading `sources:` and `ports:` get, where only the exception is
+ * declared.
+ */
+export declare function resolveConventions(input?: ConventionsInput): Conventions;
+/** The package name a frond answers to. */
+export declare function frondPackage(name: string, conventions: Conventions): string;
+/**
+ * Directories whose classes register as providers — two spellings, one behaviour.
+ *
+ * A project may point both roles at one directory; the scan must then read it once, or
+ * every provider would be registered twice.
+ */
+export declare function providerDirsOf(conventions: Conventions): string[];
+/**
+ * The frond vocabulary — every directory the scan reads.
+ *
+ * What a reader needs to bound a frond: the Nuxt module watches these for the root frond
+ * (watching the root itself would match every write), and a flat app's tsconfig lists
+ * them instead of `["."]`, which would swallow `app/` and `nuxt.config.ts`.
+ */
+export declare function frondDirsOf(conventions: Conventions): string[];
+/**
+ * What changes when a frond's domain changes — the paths a dev loop watches.
+ *
+ * The root frond IS the scan root, so watching its path would match every write in the
+ * project: `.nuxt/`, `node_modules/`, the build output. Its convention directories are
+ * the frond, and they are what a scan re-reads.
+ */
+export declare function watchPathsOf(frond: {
+    source: {
+        path: string;
+    };
+}, scanRoot: string, conventions: Conventions): string[];
+//# sourceMappingURL=conventions.d.ts.map

package/dist/scan/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../src/scan/conventions.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,uFAAuF;QACvF,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAajC,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,gBAAgB,GAAG,WAAW,CAMxE;AAED,2CAA2C;AAC3C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM,CAE3E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,EAAE,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,EAAE,CAK9D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE;IAAE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,WAAW,GACvB,MAAM,EAAE,CAIV"}

package/dist/scan/conventions.js

@@ -0,0 +1,82 @@
+/**
+ * The names the scan READS instead of deriving them.
+ *
+ * Everything else a frond states, it states by its shape; these seven directories and the
+ * import prefix are the one place where a name is the declaration. They were spelled as
+ * literals in five packages, so a project could not move any of them and `frondsDir` was
+ * a declared key with no reader.
+ */
+import { join } from 'node:path';
+/**
+ * What a project means when it declares nothing — the convention itself.
+ *
+ * `@fronds` and not `@frond`: the npm org for the singular belongs to someone else, and a
+ * scope is a name that must be ownable.
+ */
+export const DEFAULT_CONVENTIONS = {
+    scope: '@fronds',
+    fronds: 'fronds',
+    dirs: {
+        entities: 'entities',
+        handlers: 'handlers',
+        services: 'services',
+        repositories: 'repositories',
+        presenters: 'presenters',
+        collectors: 'collectors',
+        seeds: 'seeds',
+        versions: 'versions',
+    },
+};
+/**
+ * The convention, with a project's exceptions folded in.
+ *
+ * Merged one level into `dirs` so renaming one directory does not require restating the
+ * other six — the same reading `sources:` and `ports:` get, where only the exception is
+ * declared.
+ */
+export function resolveConventions(input) {
+    return {
+        scope: input?.scope ?? DEFAULT_CONVENTIONS.scope,
+        fronds: input?.fronds ?? DEFAULT_CONVENTIONS.fronds,
+        dirs: { ...DEFAULT_CONVENTIONS.dirs, ...input?.dirs },
+    };
+}
+/** The package name a frond answers to. */
+export function frondPackage(name, conventions) {
+    return `${conventions.scope}/${name}`;
+}
+/**
+ * Directories whose classes register as providers — two spellings, one behaviour.
+ *
+ * A project may point both roles at one directory; the scan must then read it once, or
+ * every provider would be registered twice.
+ */
+export function providerDirsOf(conventions) {
+    return [...new Set([conventions.dirs.services, conventions.dirs.repositories])];
+}
+/**
+ * The frond vocabulary — every directory the scan reads.
+ *
+ * What a reader needs to bound a frond: the Nuxt module watches these for the root frond
+ * (watching the root itself would match every write), and a flat app's tsconfig lists
+ * them instead of `["."]`, which would swallow `app/` and `nuxt.config.ts`.
+ */
+export function frondDirsOf(conventions) {
+    const { entities, handlers, presenters, collectors, seeds, versions } = conventions.dirs;
+    return [...new Set([
+            entities, handlers, presenters, collectors, seeds, versions, ...providerDirsOf(conventions),
+        ])];
+}
+/**
+ * What changes when a frond's domain changes — the paths a dev loop watches.
+ *
+ * The root frond IS the scan root, so watching its path would match every write in the
+ * project: `.nuxt/`, `node_modules/`, the build output. Its convention directories are
+ * the frond, and they are what a scan re-reads.
+ */
+export function watchPathsOf(frond, scanRoot, conventions) {
+    return frond.source.path === scanRoot
+        ? frondDirsOf(conventions).map((dir) => join(scanRoot, dir))
+        : [frond.source.path];
+}
+//# sourceMappingURL=conventions.js.map

package/dist/scan/conventions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../../src/scan/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AA0BjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC9C,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE;QACJ,QAAQ,EAAE,UAAU;QACpB,QAAQ,EAAE,UAAU;QACpB,QAAQ,EAAE,UAAU;QACpB,YAAY,EAAE,cAAc;QAC5B,UAAU,EAAE,YAAY;QACxB,UAAU,EAAE,YAAY;QACxB,KAAK,EAAE,OAAO;QACd,QAAQ,EAAE,UAAU;KACrB;CACF,CAAC;AASF;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAwB;IACzD,OAAO;QACL,KAAK,EAAE,KAAK,EAAE,KAAK,IAAI,mBAAmB,CAAC,KAAK;QAChD,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,mBAAmB,CAAC,MAAM;QACnD,IAAI,EAAE,EAAE,GAAG,mBAAmB,CAAC,IAAI,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE;KACtD,CAAC;AACJ,CAAC;AAED,2CAA2C;AAC3C,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,WAAwB;IACjE,OAAO,GAAG,WAAW,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;AACxC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,WAAwB;IACrD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,WAAwB;IAClD,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,WAAW,CAAC,IAAI,CAAC;IACzF,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC;YACjB,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAC,WAAW,CAAC;SAC5F,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAmC,EACnC,QAAgB,EAChB,WAAwB;IAExB,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;QACnC,CAAC,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/scan/emit.d.ts

@@ -0,0 +1,14 @@
+import type { ScanResult } from './frond.js';
+export interface EmitOptions {
+    /** Where the generated module will sit. Imports are written relative to it. */
+    outFile: string;
+    /** How `@fougere/core` is reached from there. Default: the package name. */
+    core?: string;
+}
+/**
+ * Write a scan down. The result is a TypeScript module whose only imports are the classes
+ * the scan found — static, so a bundler traces them — and whose only value is the
+ * descriptor `createApp` asks for.
+ */
+export declare function emitScan(result: ScanResult, options: EmitOptions): string;
+//# sourceMappingURL=emit.d.ts.map

package/dist/scan/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/scan/emit.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAwJD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CA2CzE"}