@koma-app/core 0.1.0

package/LICENSE.md

@@ -0,0 +1,14 @@
+# Licence
+
+© 2026 Koma (Yann Cherif). Tous droits réservés.
+
+Ce paquet est publié sur npm pour être installé par les sites des studios clients de la plateforme
+Koma (https://koma-app.fr). Son usage est autorisé uniquement avec un compte Koma actif, pour le site
+du studio concerné, tel que prévu par les conditions d'utilisation de la plateforme.
+
+Toute autre utilisation, reproduction, modification, redistribution ou création d'œuvre dérivée,
+en tout ou partie, est interdite sans accord écrit préalable de Koma.
+
+Le paquet est fourni « en l'état », sans garantie d'aucune sorte.
+
+Contact : contact@koma-app.fr

package/README.md

@@ -0,0 +1,25 @@
+# @koma-app/core
+
+Client typé, types, formateurs et helpers du storefront **Koma**, sans React. Base de
+[`@koma-app/react`](https://www.npmjs.com/package/@koma-app/react), utilisable seul par n'importe quel framework.
+
+```ts
+import { createKomaClient, formatPrice, groupByDay } from "@koma-app/core";
+
+const koma = createKomaClient(); // /api/v1 en même origine (site proxifié) ; sinon { baseUrl, studioKey: "pk_…" }
+const studio = await koma.studio();
+const courses = await koma.courses();
+for (const day of groupByDay(courses, { timeZone: studio.timezone, locale: studio.locale })) {
+  console.log(day.heading, day.courses.map((c) => `${c.title} ${formatPrice(c.priceCents, studio.currency)}`));
+}
+```
+
+- `createKomaClient({ baseUrl?, studioKey?, fetch?, credentials? })` : `studio`, `courses`, `course`, `cardProducts`,
+  `otpRequest`, `otpVerify`, `me`, `logout`, `account`, `trialEligibility`, `payIntent`, `cardIntent`, `payWithCredit`,
+  `requestCancellation`, `contact`. Les échecs rejettent une `KomaApiError { status, code, message }`.
+- Formateurs : `formatPrice`, `formatTime`, `formatDuration`, `formatDayHeading`, `formatFullDate`, `groupByDay`
+  (fuseau et locale du studio, jamais en dur).
+- Stockage local tolérant (`koma.*`) : identité mémorisée, réservation locale par cours, verrou post-achat, contexte essai.
+- Calendrier : `googleCalendarUrl`, `buildIcs`, `eventWindow`. SEO : `courseJsonLd`.
+
+Contrat de l'API : `docs/api.md` du dépôt Koma.

package/dist/agenda.d.ts

@@ -0,0 +1,19 @@
+import { type FormatOptions } from "./format";
+import type { AgendaCourse } from "./types";
+export type DayRelative = "today" | "tomorrow" | null;
+export type DayGroup<C extends {
+    startsAt: string;
+} = AgendaCourse> = {
+    /** YYYY-MM-DD dans le fuseau du studio. */
+    key: string;
+    relative: DayRelative;
+    /** « samedi 3 octobre » dans la locale du studio. */
+    heading: string;
+    courses: C[];
+};
+/** Groupe des cours (déjà triés par date) par jour civil du studio, avec repères Aujourd'hui / Demain. */
+export declare function groupByDay<C extends {
+    startsAt: string;
+}>(courses: C[], opts?: FormatOptions & {
+    now?: Date;
+}): DayGroup<C>[];

package/dist/agenda.js

@@ -0,0 +1,25 @@
+import { dayKey, formatDayHeading } from "./format";
+/** Groupe des cours (déjà triés par date) par jour civil du studio, avec repères Aujourd'hui / Demain. */
+export function groupByDay(courses, opts = {}) {
+    const now = opts.now ?? new Date();
+    const tz = opts.timeZone;
+    const todayKey = dayKey(now, tz);
+    const tomorrowKey = dayKey(new Date(now.getTime() + 24 * 3600 * 1000), tz);
+    const groups = [];
+    for (const course of courses) {
+        const key = dayKey(new Date(course.startsAt), tz);
+        const last = groups[groups.length - 1];
+        if (last && last.key === key) {
+            last.courses.push(course);
+        }
+        else {
+            groups.push({
+                key,
+                relative: key === todayKey ? "today" : key === tomorrowKey ? "tomorrow" : null,
+                heading: formatDayHeading(course.startsAt, { ...opts, now }),
+                courses: [course],
+            });
+        }
+    }
+    return groups;
+}

package/dist/calendar.d.ts

@@ -0,0 +1,18 @@
+export type CalendarEvent = {
+    uid: string;
+    title: string;
+    start: Date;
+    end: Date;
+    location: string;
+    description: string;
+    /** Identifiant du producteur dans le fichier .ics (ex. « Koma//Studio Lune »). */
+    prodId?: string;
+};
+/** Fenêtre d'un cours : fin réelle, ou début + durée par défaut si le cours n'a pas de fin. */
+export declare function eventWindow(startsAt: string, endsAt: string | null, defaultMinutes?: number): {
+    start: Date;
+    end: Date;
+};
+export declare const calendarStamp: (d: Date) => string;
+export declare function googleCalendarUrl(ev: CalendarEvent): string;
+export declare function buildIcs(ev: CalendarEvent, now?: Date): string;

package/dist/calendar.js

@@ -0,0 +1,36 @@
+// Ajout au calendrier : URL Google Calendar et contenu .ics (purs, sans DOM).
+/** Fenêtre d'un cours : fin réelle, ou début + durée par défaut si le cours n'a pas de fin. */
+export function eventWindow(startsAt, endsAt, defaultMinutes = 75) {
+    const start = new Date(startsAt);
+    const end = endsAt ? new Date(endsAt) : new Date(start.getTime() + defaultMinutes * 60_000);
+    return { start, end };
+}
+export const calendarStamp = (d) => d.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+export function googleCalendarUrl(ev) {
+    const params = new URLSearchParams({
+        action: "TEMPLATE",
+        text: ev.title,
+        dates: `${calendarStamp(ev.start)}/${calendarStamp(ev.end)}`,
+        location: ev.location,
+        details: ev.description,
+    });
+    return `https://calendar.google.com/calendar/render?${params.toString()}`;
+}
+const icsEscape = (s) => s.replace(/\\/g, "\\\\").replace(/[,;]/g, (c) => `\\${c}`).replace(/\n/g, "\\n");
+export function buildIcs(ev, now = new Date()) {
+    return [
+        "BEGIN:VCALENDAR",
+        "VERSION:2.0",
+        `PRODID:-//${ev.prodId ?? "Koma"}//FR`,
+        "BEGIN:VEVENT",
+        `UID:${ev.uid}`,
+        `DTSTAMP:${calendarStamp(now)}`,
+        `DTSTART:${calendarStamp(ev.start)}`,
+        `DTEND:${calendarStamp(ev.end)}`,
+        `SUMMARY:${icsEscape(ev.title)}`,
+        `LOCATION:${icsEscape(ev.location)}`,
+        `DESCRIPTION:${icsEscape(ev.description)}`,
+        "END:VEVENT",
+        "END:VCALENDAR",
+    ].join("\r\n");
+}

package/dist/client.d.ts

@@ -0,0 +1,59 @@
+import type { AccountSummary, AgendaCourse, CancellationResult, CardProduct, CheckoutIdentity, ClientInfo, CreditPaymentResult, PaymentIntentInfo, PublicCourse, Studio, TrialEligibility } from "./types";
+export type KomaClientOptions = {
+    /** Préfixe des routes storefront. Défaut `/api/v1` (site proxifié en même origine, cookie de session). */
+    baseUrl?: string;
+    /** Clé publique `pk_…` du studio, si le site n'est pas servi sur un domaine déclaré du studio. */
+    studioKey?: string;
+    /** `fetch` à utiliser (tests, SSR). Défaut : `globalThis.fetch`. */
+    fetch?: typeof fetch;
+    /** Envoi des cookies. Défaut `same-origin` (proxy) ; `include` si l'API est sur un autre domaine déclaré. */
+    credentials?: RequestCredentials;
+};
+export type KomaClient = ReturnType<typeof createKomaClient>;
+/** Client HTTP typé du storefront Koma. Chaque méthode rejette avec une `KomaApiError` en cas d'échec. */
+export declare function createKomaClient(options?: KomaClientOptions): {
+    /** Identité publique du studio (clé Stripe, essai, fuseau, prix par défaut, branding). */
+    studio: () => Promise<Studio>;
+    /** Agenda public : cours publiés, à venir, visibles dans le planning. */
+    courses: () => Promise<AgendaCourse[]>;
+    /** Détail d'un cours publié (404 sinon). */
+    course: (slug: string) => Promise<PublicCourse>;
+    /** Catalogue public des cartes actives. */
+    cardProducts: () => Promise<CardProduct[]>;
+    /** Demande un code de connexion. Sans `force`, un email inconnu ne reçoit rien (`unknownAccount`). */
+    otpRequest: (email: string, force?: boolean) => Promise<{
+        ok: true;
+        unknownAccount?: boolean;
+    }>;
+    otpVerify: (email: string, code: string) => Promise<{
+        authenticated: true;
+        client: ClientInfo;
+    }>;
+    /** Session en cours, ou null (401 ou réseau). */
+    me: () => Promise<ClientInfo | null>;
+    logout: () => Promise<{
+        ok: true;
+    }>;
+    /** Cartes actives + réservations à venir du compte connecté (401 sinon). */
+    account: () => Promise<AccountSummary>;
+    /** Confort UX : `payIntent` refait foi. */
+    trialEligibility: (email: string) => Promise<TrialEligibility>;
+    /** PaymentIntent pour un cours (plein tarif, ou essai avec `trial`). Montant calculé côté API. */
+    payIntent: (slug: string, identity: CheckoutIdentity, trial?: {
+        level: string;
+    }) => Promise<PaymentIntentInfo>;
+    /** PaymentIntent pour une carte ; `courseSlug` = combo « carte + réservation de ce cours ». */
+    cardIntent: (cardProductId: string, identity: CheckoutIdentity, courseSlug?: string) => Promise<PaymentIntentInfo>;
+    /** Réservation immédiate avec un crédit (session requise). */
+    payWithCredit: (slug: string, name?: string) => Promise<CreditPaymentResult>;
+    /** Demande d'annulation (session requise) ; le studio finalise depuis le BO. */
+    requestCancellation: (slug: string) => Promise<CancellationResult>;
+    contact: (data: {
+        name: string;
+        email: string;
+        message: string;
+        website?: string;
+    }) => Promise<{
+        success: true;
+    }>;
+};

package/dist/client.js

@@ -0,0 +1,73 @@
+import { KomaApiError, errorFromResponse } from "./errors";
+/** Client HTTP typé du storefront Koma. Chaque méthode rejette avec une `KomaApiError` en cas d'échec. */
+export function createKomaClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? "/api/v1").replace(/\/$/, "");
+    const doFetch = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!doFetch)
+        throw new Error("@koma-app/core : aucun `fetch` disponible.");
+    const credentials = options.credentials ?? "same-origin";
+    async function request(method, path, body) {
+        const headers = {};
+        if (options.studioKey)
+            headers["x-studio-key"] = options.studioKey;
+        if (body !== undefined)
+            headers["content-type"] = "application/json";
+        let res;
+        try {
+            res = await doFetch(`${baseUrl}${path}`, {
+                method,
+                headers,
+                credentials,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+            });
+        }
+        catch {
+            throw new KomaApiError("Connexion impossible. Vérifiez votre réseau et réessayez.", 0, "NETWORK");
+        }
+        if (!res.ok)
+            throw await errorFromResponse(res);
+        if (res.status === 204)
+            return undefined;
+        return (await res.json());
+    }
+    const get = (path) => request("GET", path);
+    const post = (path, body = {}) => request("POST", path, body);
+    const enc = encodeURIComponent;
+    return {
+        /** Identité publique du studio (clé Stripe, essai, fuseau, prix par défaut, branding). */
+        studio: () => get("/studio"),
+        /** Agenda public : cours publiés, à venir, visibles dans le planning. */
+        courses: () => get("/courses"),
+        /** Détail d'un cours publié (404 sinon). */
+        course: (slug) => get(`/courses/${enc(slug)}`),
+        /** Catalogue public des cartes actives. */
+        cardProducts: () => get("/card-products"),
+        /** Demande un code de connexion. Sans `force`, un email inconnu ne reçoit rien (`unknownAccount`). */
+        otpRequest: (email, force = false) => post("/auth/otp/request", force ? { email, force: true } : { email }),
+        otpVerify: (email, code) => post("/auth/otp/verify", { email, code }),
+        /** Session en cours, ou null (401 ou réseau). */
+        me: async () => {
+            try {
+                const r = await get("/me");
+                return r.authenticated && r.client ? r.client : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        logout: () => post("/auth/logout"),
+        /** Cartes actives + réservations à venir du compte connecté (401 sinon). */
+        account: () => get("/account"),
+        /** Confort UX : `payIntent` refait foi. */
+        trialEligibility: (email) => post("/essai/eligibility", { email }),
+        /** PaymentIntent pour un cours (plein tarif, ou essai avec `trial`). Montant calculé côté API. */
+        payIntent: (slug, identity, trial) => post("/pay/intent", { ...identity, slug, ...(trial ? { trial: true, level: trial.level } : {}) }),
+        /** PaymentIntent pour une carte ; `courseSlug` = combo « carte + réservation de ce cours ». */
+        cardIntent: (cardProductId, identity, courseSlug) => post("/pay/card-intent", { ...identity, cardProductId, ...(courseSlug ? { courseSlug } : {}) }),
+        /** Réservation immédiate avec un crédit (session requise). */
+        payWithCredit: (slug, name) => post("/pay/credit", name ? { slug, name } : { slug }),
+        /** Demande d'annulation (session requise) ; le studio finalise depuis le BO. */
+        requestCancellation: (slug) => post(`/courses/${enc(slug)}/cancel`),
+        contact: (data) => post("/contact", data),
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+/** Erreur renvoyée par l'API Koma : `{ error: "message lisible", code?: "CODE" }`. */
+export declare class KomaApiError extends Error {
+    readonly status: number;
+    readonly code: string | undefined;
+    constructor(message: string, status: number, code?: string);
+}
+export declare const DEFAULT_ERROR_MESSAGE = "Une erreur est survenue.";
+/** Lit le corps d'erreur JSON de l'API (tolère un corps vide ou non JSON). */
+export declare function errorFromResponse(res: Response): Promise<KomaApiError>;

package/dist/errors.js

@@ -0,0 +1,28 @@
+/** Erreur renvoyée par l'API Koma : `{ error: "message lisible", code?: "CODE" }`. */
+export class KomaApiError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.name = "KomaApiError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export const DEFAULT_ERROR_MESSAGE = "Une erreur est survenue.";
+/** Lit le corps d'erreur JSON de l'API (tolère un corps vide ou non JSON). */
+export async function errorFromResponse(res) {
+    let message = DEFAULT_ERROR_MESSAGE;
+    let code;
+    try {
+        const body = (await res.json());
+        if (typeof body?.error === "string" && body.error)
+            message = body.error;
+        if (typeof body?.code === "string")
+            code = body.code;
+    }
+    catch {
+        /* corps vide ou HTML */
+    }
+    return new KomaApiError(message, res.status, code);
+}

package/dist/format.d.ts

@@ -0,0 +1,18 @@
+export type FormatOptions = {
+    locale?: string;
+    timeZone?: string;
+};
+/** `1800` → « 18 € », `1650` → « 16,50 € ». Devise en minuscules côté API (`eur`). */
+export declare function formatPrice(cents: number, currency?: string, locale?: string): string;
+/** « 18h30 » en français, « 6:30 PM » ailleurs. */
+export declare function formatTime(iso: string, opts?: FormatOptions): string;
+/** « 1 h 30 », « 1 h », « 45 min » ; null sans fin ou si la durée est nulle. */
+export declare function formatDuration(startIso: string, endIso: string | null): string | null;
+/** « samedi 3 octobre » (année ajoutée si différente de l'année courante). */
+export declare function formatDayHeading(iso: string, opts?: FormatOptions & {
+    now?: Date;
+}): string;
+/** « samedi 3 octobre 2026 » (toujours avec l'année : page cours, compte). */
+export declare function formatFullDate(iso: string, opts?: FormatOptions): string;
+/** Jour civil dans le fuseau (YYYY-MM-DD) — clé de groupement. */
+export declare function dayKey(date: Date, timeZone?: string): string;

package/dist/format.js

@@ -0,0 +1,48 @@
+// Formateurs d'affichage. Le fuseau vient toujours du studio (`Studio.timezone`), jamais en dur.
+const DEFAULTS = { locale: "fr-FR", timeZone: "Europe/Paris" };
+/** `1800` → « 18 € », `1650` → « 16,50 € ». Devise en minuscules côté API (`eur`). */
+export function formatPrice(cents, currency = "eur", locale = DEFAULTS.locale) {
+    const whole = cents % 100 === 0;
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currency.toUpperCase(),
+        minimumFractionDigits: whole ? 0 : 2,
+        maximumFractionDigits: whole ? 0 : 2,
+    }).format(cents / 100);
+}
+/** « 18h30 » en français, « 6:30 PM » ailleurs. */
+export function formatTime(iso, opts = {}) {
+    const locale = opts.locale ?? DEFAULTS.locale;
+    const s = new Intl.DateTimeFormat(locale, { hour: "2-digit", minute: "2-digit", timeZone: opts.timeZone ?? DEFAULTS.timeZone }).format(new Date(iso));
+    return locale.startsWith("fr") ? s.replace(":", "h") : s;
+}
+/** « 1 h 30 », « 1 h », « 45 min » ; null sans fin ou si la durée est nulle. */
+export function formatDuration(startIso, endIso) {
+    if (!endIso)
+        return null;
+    const mins = Math.round((new Date(endIso).getTime() - new Date(startIso).getTime()) / 60_000);
+    if (mins <= 0)
+        return null;
+    const h = Math.floor(mins / 60);
+    const m = mins % 60;
+    if (h === 0)
+        return `${m} min`;
+    return m > 0 ? `${h} h ${String(m).padStart(2, "0")}` : `${h} h`;
+}
+/** « samedi 3 octobre » (année ajoutée si différente de l'année courante). */
+export function formatDayHeading(iso, opts = {}) {
+    const locale = opts.locale ?? DEFAULTS.locale;
+    const timeZone = opts.timeZone ?? DEFAULTS.timeZone;
+    const date = new Date(iso);
+    const year = (d) => new Intl.DateTimeFormat(locale, { year: "numeric", timeZone }).format(d);
+    const sameYear = year(date) === year(opts.now ?? new Date());
+    return new Intl.DateTimeFormat(locale, { weekday: "long", day: "numeric", month: "long", ...(sameYear ? {} : { year: "numeric" }), timeZone }).format(date);
+}
+/** « samedi 3 octobre 2026 » (toujours avec l'année : page cours, compte). */
+export function formatFullDate(iso, opts = {}) {
+    return new Intl.DateTimeFormat(opts.locale ?? DEFAULTS.locale, { weekday: "long", day: "numeric", month: "long", year: "numeric", timeZone: opts.timeZone ?? DEFAULTS.timeZone }).format(new Date(iso));
+}
+/** Jour civil dans le fuseau (YYYY-MM-DD) — clé de groupement. */
+export function dayKey(date, timeZone = DEFAULTS.timeZone) {
+    return new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).format(date);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export { KomaApiError, DEFAULT_ERROR_MESSAGE } from "./errors";
+export { createKomaClient, type KomaClient, type KomaClientOptions } from "./client";
+export * from "./format";
+export * from "./agenda";
+export * from "./storage";
+export * from "./calendar";
+export * from "./seo";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./types";
+export { KomaApiError, DEFAULT_ERROR_MESSAGE } from "./errors";
+export { createKomaClient } from "./client";
+export * from "./format";
+export * from "./agenda";
+export * from "./storage";
+export * from "./calendar";
+export * from "./seo";

package/dist/seo.d.ts

@@ -0,0 +1,19 @@
+import type { AgendaCourse } from "./types";
+export type JsonLdOptions = {
+    /** URL publique de la page d'un cours (ex. `slug => https://www.mon-studio.fr/cours/${slug}`). */
+    courseUrl: (slug: string) => string;
+    /** Organisateur / intervenant (le studio ou le professeur). */
+    organizer: {
+        name: string;
+        url?: string;
+        type?: "Person" | "Organization";
+    };
+    /** Image partagée (og:image) — recommandée par Google pour les événements. */
+    image?: string | string[];
+    /** Ville et pays du lieu (l'API ne renvoie que le nom et l'adresse). */
+    locality?: string;
+    country?: string;
+    currency?: string;
+};
+/** Données structurées schema.org `Event` d'un cours de l'agenda, à injecter dans un `<script type="application/ld+json">`. */
+export declare function courseJsonLd(c: AgendaCourse, o: JsonLdOptions): Record<string, unknown>;

package/dist/seo.js

@@ -0,0 +1,35 @@
+/** Données structurées schema.org `Event` d'un cours de l'agenda, à injecter dans un `<script type="application/ld+json">`. */
+export function courseJsonLd(c, o) {
+    const who = { "@type": o.organizer.type ?? "Organization", name: o.organizer.name, ...(o.organizer.url ? { url: o.organizer.url } : {}) };
+    return {
+        "@context": "https://schema.org",
+        "@type": "Event",
+        name: c.title,
+        startDate: c.startsAt,
+        ...(c.endsAt ? { endDate: c.endsAt } : {}),
+        ...(c.description ? { description: c.description } : {}),
+        ...(o.image ? { image: Array.isArray(o.image) ? o.image : [o.image] } : {}),
+        location: {
+            "@type": "Place",
+            name: c.locationName,
+            address: {
+                "@type": "PostalAddress",
+                streetAddress: c.locationAddress,
+                ...(o.locality ? { addressLocality: o.locality } : {}),
+                ...(o.country ? { addressCountry: o.country } : {}),
+            },
+        },
+        organizer: who,
+        performer: who,
+        eventAttendanceMode: "https://schema.org/OfflineEventAttendanceMode",
+        eventStatus: "https://schema.org/EventScheduled",
+        offers: {
+            "@type": "Offer",
+            url: o.courseUrl(c.slug),
+            price: (c.priceCents / 100).toFixed(2),
+            priceCurrency: (o.currency ?? "eur").toUpperCase(),
+            availability: c.full ? "https://schema.org/SoldOut" : "https://schema.org/InStock",
+            ...(c.createdAt ? { validFrom: c.createdAt } : {}),
+        },
+    };
+}

package/dist/storage.d.ts

@@ -0,0 +1,23 @@
+import type { CheckoutIdentity } from "./types";
+type StorageLike = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+/** Nom et email mémorisés pour pré-remplir les prochains achats (localStorage). */
+export declare function loadSavedIdentity(store?: StorageLike | null): CheckoutIdentity;
+export declare function saveIdentity(identity: CheckoutIdentity, store?: StorageLike | null): void;
+/** Réservation mémorisée par cours : la page ré-affiche « C'est confirmé » sans session (le serveur fait foi une fois connecté). */
+export declare function localReservationEmail(slug: string, store?: StorageLike | null): string | null;
+export declare function saveLocalReservation(slug: string, email: string, store?: StorageLike | null): void;
+export declare function clearLocalReservation(slug: string, store?: StorageLike | null): void;
+/** Verrou post-paiement (sessionStorage) : la connexion reste sur l'email d'achat le temps de l'onglet. */
+export declare function savePurchaseLock(email: string, store?: StorageLike | null): void;
+export declare function purchaseLockEmail(store?: StorageLike | null): string | null;
+export declare function clearPurchaseLock(store?: StorageLike | null): void;
+/** Contexte du parcours essai (sessionStorage) : /essai → page cours en mode essai. */
+export type TrialInfo = {
+    name: string;
+    email: string;
+    level: string;
+};
+export declare function saveTrialInfo(info: TrialInfo, store?: StorageLike | null): void;
+export declare function loadTrialInfo(store?: StorageLike | null): TrialInfo | null;
+export declare function clearTrialInfo(store?: StorageLike | null): void;
+export {};

package/dist/storage.js

@@ -0,0 +1,70 @@
+// Mémoire de l'appareil (localStorage / sessionStorage), tolérante à la navigation privée.
+// Préfixe `koma.` ; un `Storage` peut être injecté (tests, SSR).
+const PREFIX = "koma.";
+const local = () => (typeof localStorage !== "undefined" ? localStorage : null);
+const session = () => (typeof sessionStorage !== "undefined" ? sessionStorage : null);
+function read(store, key) {
+    try {
+        const raw = store?.getItem(PREFIX + key);
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function write(store, key, value) {
+    try {
+        store?.setItem(PREFIX + key, JSON.stringify(value));
+    }
+    catch {
+        /* navigation privée : pas bloquant */
+    }
+}
+function remove(store, key) {
+    try {
+        store?.removeItem(PREFIX + key);
+    }
+    catch {
+        /* rien */
+    }
+}
+/** Nom et email mémorisés pour pré-remplir les prochains achats (localStorage). */
+export function loadSavedIdentity(store = local()) {
+    const saved = read(store, "identity");
+    return { name: saved?.name ?? "", email: saved?.email ?? "", website: "" };
+}
+export function saveIdentity(identity, store = local()) {
+    write(store, "identity", { name: identity.name, email: identity.email });
+}
+/** Réservation mémorisée par cours : la page ré-affiche « C'est confirmé » sans session (le serveur fait foi une fois connecté). */
+export function localReservationEmail(slug, store = local()) {
+    return read(store, `reserved.${slug}`)?.email ?? null;
+}
+export function saveLocalReservation(slug, email, store = local()) {
+    write(store, `reserved.${slug}`, { email: email.trim().toLowerCase(), at: new Date().toISOString() });
+}
+export function clearLocalReservation(slug, store = local()) {
+    remove(store, `reserved.${slug}`);
+}
+/** Verrou post-paiement (sessionStorage) : la connexion reste sur l'email d'achat le temps de l'onglet. */
+export function savePurchaseLock(email, store = session()) {
+    write(store, "purchase-lock", email.trim().toLowerCase());
+}
+export function purchaseLockEmail(store = session()) {
+    return read(store, "purchase-lock") || null;
+}
+export function clearPurchaseLock(store = session()) {
+    remove(store, "purchase-lock");
+}
+export function saveTrialInfo(info, store = session()) {
+    write(store, "trial", info);
+}
+export function loadTrialInfo(store = session()) {
+    const saved = read(store, "trial");
+    if (!saved?.email || !saved.level)
+        return null;
+    return { name: saved.name ?? "", email: saved.email, level: saved.level };
+}
+export function clearTrialInfo(store = session()) {
+    remove(store, "trial");
+}

package/dist/types.d.ts

@@ -0,0 +1,108 @@
+export type StudioBranding = Record<string, unknown> | null;
+export type Studio = {
+    slug: string;
+    name: string;
+    locale: string;
+    currency: string;
+    timezone: string;
+    trialEnabled: boolean;
+    trialPriceCents: number | null;
+    cancellationMinHours: number;
+    /** Prix d'un cours à l'unité (affichage Tarifs) ; null si le studio ne l'a pas renseigné. */
+    defaultPriceCents: number | null;
+    publicBaseUrl: string | null;
+    /** Clé publishable Stripe du studio : initialise Stripe.js côté site. */
+    stripePublishableKey: string | null;
+    branding: StudioBranding;
+};
+/** Cours de l'agenda public (`GET /courses`). */
+export type AgendaCourse = {
+    slug: string;
+    title: string;
+    startsAt: string;
+    endsAt: string | null;
+    priceCents: number;
+    locationName: string;
+    locationAddress: string;
+    description: string | null;
+    createdAt: string;
+    spotsLeft: number;
+    full: boolean;
+    myRegistered: boolean;
+};
+export type MyReservation = {
+    createdAt: string;
+    cancellationRequestedAt: string | null;
+};
+export type MyCredits = {
+    total: number;
+    nextExpiresAt: string | null;
+};
+/** Détail d'un cours (`GET /courses/:slug`). `kind` = clé du type (`cours`, `stage`, …). */
+export type PublicCourse = AgendaCourse & {
+    kind: string;
+    capacity: number;
+    listed: boolean;
+    cardAccepted: boolean;
+    cancellationMinHours: number;
+    myReservation: MyReservation | null;
+    myCredits: MyCredits | null;
+};
+export type CardProduct = {
+    id: string;
+    name: string;
+    credits: number;
+    priceCents: number;
+    validityMonths: number;
+    position: number;
+};
+export type ClientInfo = {
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+};
+export type AccountCard = {
+    id: number;
+    creditsLeft: number;
+    totalCredits: number;
+    expiresAt: string;
+};
+export type PaymentMethod = "onsite" | "card" | "credit";
+export type AccountReservation = {
+    courseSlug: string;
+    courseKind: string;
+    courseTitle: string;
+    startsAt: string;
+    endsAt: string | null;
+    locationName: string;
+    paymentMethod: PaymentMethod;
+    cancellationRequestedAt: string | null;
+};
+export type AccountSummary = {
+    email: string;
+    cards: AccountCard[];
+    reservations: AccountReservation[];
+};
+/** Identité saisie au paiement : un seul champ « Prénom et nom » + email (décision du 26/09). */
+export type CheckoutIdentity = {
+    name: string;
+    email: string;
+    website?: string;
+};
+export type PaymentIntentInfo = {
+    clientSecret: string;
+    amountCents: number;
+};
+export type TrialEligibility = {
+    eligible: boolean;
+    trialEnabled: boolean;
+};
+export type CreditPaymentResult = {
+    success: true;
+    creditsLeft: number;
+    nextExpiresAt: string | null;
+};
+export type CancellationResult = {
+    success: true;
+    cancellationRequestedAt: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+// Types des réponses du storefront Koma (`/api/v1`). Source de vérité : docs/api.md.
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@koma-app/core",
+  "version": "0.1.0",
+  "description": "Client typé, types et formateurs du storefront Koma — sans React.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "Koma <contact@koma-app.fr>",
+  "homepage": "https://koma-app.fr",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yannsheriff/studioflow.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "koma",
+    "studio",
+    "cours",
+    "réservation",
+    "api-client"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.7"
+  }
+}