@saasicat/nest 0.2.0

package/dist/chunk-L4SUWH5B.js

@@ -0,0 +1,14 @@
+// src/discovery/tokens.ts
+var IMPLEMENTS_CAPABILITY_KEY = "discovery:implements-capability";
+var REQUIRES_CAPABILITY_KEY = "discovery:requires-capability";
+var DEFINES_QUOTA_KEY = "discovery:defines-quota";
+var ENFORCE_QUOTA_KEY = "discovery:enforce-quota";
+var DISCOVERY_SNAPSHOT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/DiscoverySnapshot");
+
+export {
+  IMPLEMENTS_CAPABILITY_KEY,
+  REQUIRES_CAPABILITY_KEY,
+  DEFINES_QUOTA_KEY,
+  ENFORCE_QUOTA_KEY,
+  DISCOVERY_SNAPSHOT_TOKEN
+};

package/dist/chunk-M6CZQYPY.js

@@ -0,0 +1,314 @@
+import {
+  DEFINES_QUOTA_KEY,
+  ENFORCE_QUOTA_KEY,
+  IMPLEMENTS_CAPABILITY_KEY
+} from "./chunk-L4SUWH5B.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/discovery/discovery.scanner.ts
+import { createHash } from "crypto";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { DiscoveryService, MetadataScanner, Reflector } from "@nestjs/core";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var DEFAULT_APP_INFO = {
+  key: "unknown",
+  version: "0.0.0"
+};
+var DISCOVERY_APP_INFO_TOKEN = /* @__PURE__ */ Symbol("DISCOVERY_APP_INFO");
+var DISCOVERY_SNAPSHOT_PATH_TOKEN = /* @__PURE__ */ Symbol("DISCOVERY_SNAPSHOT_PATH");
+var DiscoveryScanner = class _DiscoveryScanner {
+  static {
+    __name(this, "DiscoveryScanner");
+  }
+  discoveryService;
+  metadataScanner;
+  reflector;
+  appInfo;
+  snapshotPath;
+  logger = new Logger(_DiscoveryScanner.name);
+  snapshot = null;
+  // Explicit @Inject instead of type reflection: in the platform package
+  // build tsup/esbuild do not emit `design:paramtypes` metadata, so Nest
+  // cannot otherwise resolve the DI targets at the constructor
+  // (UndefinedDependencyException at the consumer's boot). Pattern
+  // analogous to admin/admin-manifest.module.ts.
+  constructor(discoveryService, metadataScanner, reflector, appInfo = DEFAULT_APP_INFO, snapshotPath = null) {
+    this.discoveryService = discoveryService;
+    this.metadataScanner = metadataScanner;
+    this.reflector = reflector;
+    this.appInfo = appInfo;
+    this.snapshotPath = snapshotPath;
+  }
+  onApplicationBootstrap() {
+    this.snapshot = this.buildSnapshot();
+    this.logger.log(`Discovery snapshot built: ${this.snapshot.capabilities.length} capabilities, ${this.snapshot.features.length} features, ${this.snapshot.quotas.length} quotas (hash=${this.snapshot.hash.slice(0, 12)}\u2026)`);
+    if (this.snapshotPath) {
+      this.persistSnapshot(this.snapshotPath, this.snapshot);
+    }
+  }
+  persistSnapshot(path, snapshot) {
+    try {
+      mkdirSync(dirname(path), {
+        recursive: true
+      });
+      writeFileSync(path, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+      this.logger.log(`Discovery snapshot persisted to ${path}`);
+    } catch (err) {
+      this.logger.warn(`Discovery snapshot konnte nicht nach ${path} geschrieben werden: ${err.message}`);
+    }
+  }
+  /**
+   * Returns the boot-time snapshot. Before `onApplicationBootstrap` (e.g. in
+   * tests) the snapshot is built lazily.
+   */
+  getSnapshot() {
+    if (!this.snapshot) {
+      this.snapshot = this.buildSnapshot();
+    }
+    return this.snapshot;
+  }
+  /**
+   * Forces a re-scan (SuperAdmin "re-run discovery" or tests with
+   * dynamically registered providers). `scannedAt` is set anew and the
+   * snapshot — as at boot — is persisted to disk so that the last scan
+   * actually performed is preserved.
+   */
+  rebuildSnapshot() {
+    this.snapshot = this.buildSnapshot();
+    if (this.snapshotPath) {
+      this.persistSnapshot(this.snapshotPath, this.snapshot);
+    }
+    return this.snapshot;
+  }
+  buildSnapshot() {
+    const capabilitiesByKey = /* @__PURE__ */ new Map();
+    const quotasByKey = /* @__PURE__ */ new Map();
+    const enforceRefs = [];
+    const wrappers = [
+      ...this.discoveryService.getProviders(),
+      ...this.discoveryService.getControllers()
+    ];
+    for (const wrapper of wrappers) {
+      const instance = wrapper.instance;
+      if (!instance || typeof instance !== "object") continue;
+      const ctor = instance.constructor;
+      if (!ctor) continue;
+      const quotaOpts = this.reflector.get(DEFINES_QUOTA_KEY, ctor);
+      if (quotaOpts) {
+        this.registerQuota(quotasByKey, quotaOpts, ctor.name);
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+      for (const methodName of methodNames) {
+        const methodRef = instance[methodName];
+        if (typeof methodRef !== "function") continue;
+        const capMeta = this.reflector.get(IMPLEMENTS_CAPABILITY_KEY, methodRef);
+        if (capMeta) {
+          this.registerCapability(capabilitiesByKey, capMeta, `${ctor.name}.${methodName}`);
+        }
+        const enforceMeta = this.reflector.get(ENFORCE_QUOTA_KEY, methodRef);
+        if (enforceMeta && capMeta) {
+          enforceRefs.push({
+            capabilityKey: capMeta.capabilityKey,
+            quotaKey: enforceMeta.quotaKey
+          });
+        }
+      }
+    }
+    const capabilities = sortByKey([
+      ...capabilitiesByKey.values()
+    ], (c) => c.capabilityKey);
+    const features = aggregateFeatures(capabilities);
+    const quotas = sortByKey(decorateQuotasWithEnforcers([
+      ...quotasByKey.values()
+    ], enforceRefs), (q) => q.quotaKey);
+    const snapshot = {
+      schemaVersion: 1,
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      app: {
+        ...this.appInfo
+      },
+      capabilities,
+      features,
+      quotas,
+      hash: ""
+    };
+    snapshot.hash = computeSnapshotHash(snapshot);
+    return snapshot;
+  }
+  registerCapability(target, meta, declaredAt) {
+    const existing = target.get(meta.capabilityKey);
+    if (existing) {
+      this.logger.warn(`Capability '${meta.capabilityKey}' wird an mehreren Stellen deklariert (${existing.declaredAt} und ${declaredAt}); erste Deklaration gewinnt`);
+      return;
+    }
+    target.set(meta.capabilityKey, {
+      capabilityKey: meta.capabilityKey,
+      label: meta.label ?? null,
+      feature: meta.feature ?? null,
+      status: meta.status ?? "active",
+      kind: meta.kind ?? "endpoint",
+      owner: meta.owner ?? null,
+      replacementKey: meta.replacementKey ?? null,
+      removalPlannedAt: meta.removalPlannedAt ?? null,
+      reason: meta.reason ?? null,
+      requires: normalizeKeyList(meta.requires),
+      replaces: normalizeKeyList(meta.replaces),
+      declaredAt
+    });
+  }
+  registerQuota(target, opts, declaredAt) {
+    const existing = target.get(opts.key);
+    if (existing) {
+      this.logger.warn(`Quota '${opts.key}' wird an mehreren Stellen definiert (${existing.declaredAt} und ${declaredAt}); erste Definition gewinnt`);
+      return;
+    }
+    target.set(opts.key, {
+      quotaKey: opts.key,
+      label: opts.label,
+      unit: opts.unit,
+      policy: opts.policy,
+      feature: opts.feature ?? null,
+      replaces: normalizeKeyList(opts.replaces),
+      declaredAt,
+      enforcedBy: []
+    });
+  }
+};
+DiscoveryScanner = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(DiscoveryService)),
+  _ts_param(1, Inject(MetadataScanner)),
+  _ts_param(2, Inject(Reflector)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(DISCOVERY_APP_INFO_TOKEN)),
+  _ts_param(4, Optional()),
+  _ts_param(4, Inject(DISCOVERY_SNAPSHOT_PATH_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner,
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof DiscoveryAppInfo === "undefined" ? Object : DiscoveryAppInfo,
+    Object
+  ])
+], DiscoveryScanner);
+function aggregateFeatures(capabilities) {
+  const byFeature = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    if (!cap.feature) continue;
+    const acc = byFeature.get(cap.feature) ?? {
+      capabilityKeys: [],
+      requires: /* @__PURE__ */ new Set(),
+      replaces: /* @__PURE__ */ new Set()
+    };
+    acc.capabilityKeys.push(cap.capabilityKey);
+    for (const key of cap.requires ?? []) acc.requires.add(key);
+    for (const key of cap.replaces ?? []) acc.replaces.add(key);
+    byFeature.set(cap.feature, acc);
+  }
+  return sortByKey([
+    ...byFeature.entries()
+  ].map(([featureKey, acc]) => {
+    acc.requires.delete(featureKey);
+    acc.replaces.delete(featureKey);
+    return {
+      featureKey,
+      capabilityKeys: [
+        ...acc.capabilityKeys
+      ].sort((a, b) => a.localeCompare(b)),
+      requires: setToSortedListOrNull(acc.requires),
+      replaces: setToSortedListOrNull(acc.replaces)
+    };
+  }), (f) => f.featureKey);
+}
+__name(aggregateFeatures, "aggregateFeatures");
+function normalizeKeyList(keys) {
+  if (!keys || keys.length === 0) return null;
+  return [
+    ...new Set(keys)
+  ].sort((a, b) => a.localeCompare(b));
+}
+__name(normalizeKeyList, "normalizeKeyList");
+function setToSortedListOrNull(keys) {
+  if (keys.size === 0) return null;
+  return [
+    ...keys
+  ].sort((a, b) => a.localeCompare(b));
+}
+__name(setToSortedListOrNull, "setToSortedListOrNull");
+function decorateQuotasWithEnforcers(quotas, enforceRefs) {
+  const enforcedByQuota = /* @__PURE__ */ new Map();
+  for (const ref of enforceRefs) {
+    const set = enforcedByQuota.get(ref.quotaKey) ?? /* @__PURE__ */ new Set();
+    set.add(ref.capabilityKey);
+    enforcedByQuota.set(ref.quotaKey, set);
+  }
+  return quotas.map((q) => ({
+    ...q,
+    enforcedBy: [
+      ...enforcedByQuota.get(q.quotaKey) ?? /* @__PURE__ */ new Set()
+    ].sort((a, b) => a.localeCompare(b))
+  }));
+}
+__name(decorateQuotasWithEnforcers, "decorateQuotasWithEnforcers");
+function sortByKey(items, keyFn) {
+  return [
+    ...items
+  ].sort((a, b) => keyFn(a).localeCompare(keyFn(b)));
+}
+__name(sortByKey, "sortByKey");
+function computeSnapshotHash(snapshot) {
+  const stableInput = {
+    schemaVersion: snapshot.schemaVersion,
+    appKey: snapshot.app.key,
+    capabilities: snapshot.capabilities.map((c) => ({
+      ...c
+    })),
+    features: snapshot.features,
+    quotas: snapshot.quotas
+  };
+  const json = canonicalStringify(stableInput);
+  return `sha256-${createHash("sha256").update(json).digest("hex")}`;
+}
+__name(computeSnapshotHash, "computeSnapshotHash");
+function canonicalStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const k of Object.keys(val).sort()) {
+        sorted[k] = val[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+__name(canonicalStringify, "canonicalStringify");
+
+export {
+  DISCOVERY_APP_INFO_TOKEN,
+  DISCOVERY_SNAPSHOT_PATH_TOKEN,
+  DiscoveryScanner,
+  computeSnapshotHash
+};

package/dist/chunk-MDIZUVIK.js

@@ -0,0 +1,87 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/checkout-offer/discount-line-items.ts
+function appendImplicitDiscountLineItem(input) {
+  const lineItems = input.lineItems.map((item) => cloneCheckoutOfferLineItem(item));
+  const discountNet = roundMoney(input.priceBreakdown.regularNet - input.priceBreakdown.effectiveNet);
+  if (lineItems.some((item) => item.kind === "discount" && !isGeneratedDiscount(item))) {
+    return lineItems;
+  }
+  const lineItemsWithoutGeneratedDiscount = lineItems.filter((item) => !isGeneratedDiscount(item));
+  if (discountNet <= 0) {
+    return lineItemsWithoutGeneratedDiscount;
+  }
+  return [
+    ...lineItemsWithoutGeneratedDiscount,
+    createDiscountLineItem(input, discountNet)
+  ];
+}
+__name(appendImplicitDiscountLineItem, "appendImplicitDiscountLineItem");
+function cloneCheckoutOfferLineItem(item) {
+  return {
+    ...item,
+    featuresSnapshot: [
+      ...item.featuresSnapshot ?? []
+    ],
+    quotaEffectsSnapshot: {
+      ...item.quotaEffectsSnapshot ?? {}
+    },
+    metadata: cloneRecord(item.metadata)
+  };
+}
+__name(cloneCheckoutOfferLineItem, "cloneCheckoutOfferLineItem");
+function createDiscountLineItem(input, discountNet) {
+  const promoCode = input.promoCodeSnapshot ?? null;
+  const firstPromotion = input.promotionSnapshots?.[0] ?? null;
+  const discountGross = roundMoney(discountNet * (1 + input.priceBreakdown.vatRate));
+  return {
+    kind: "discount",
+    sourceKey: promoCode?.code ?? firstPromotion?.id ?? "price-discount",
+    sourceVersionId: null,
+    titleSnapshot: promoCode?.label ?? firstPromotion?.label ?? "Rabatt",
+    descriptionSnapshot: promoCode ? `Promo-Code ${promoCode.code}` : null,
+    quantity: 1,
+    unit: null,
+    priceNet: -discountNet,
+    priceGross: -discountGross,
+    billingCycle: input.billingCycle,
+    featuresSnapshot: [],
+    quotaEffectsSnapshot: {},
+    metadata: {
+      generated: true,
+      source: promoCode ? "promo_code" : firstPromotion ? "promotion" : "price_breakdown",
+      discountNet,
+      discountGross,
+      promotionSnapshots: cloneArray(input.promotionSnapshots ?? []),
+      promoCodeSnapshot: cloneJsonValue(promoCode)
+    }
+  };
+}
+__name(createDiscountLineItem, "createDiscountLineItem");
+function roundMoney(value) {
+  return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+__name(roundMoney, "roundMoney");
+function isGeneratedDiscount(item) {
+  return item.kind === "discount" && item.metadata?.generated === true;
+}
+__name(isGeneratedDiscount, "isGeneratedDiscount");
+function cloneRecord(value) {
+  if (!value) return null;
+  return cloneJsonValue(value);
+}
+__name(cloneRecord, "cloneRecord");
+function cloneArray(value) {
+  return cloneJsonValue(value);
+}
+__name(cloneArray, "cloneArray");
+function cloneJsonValue(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+__name(cloneJsonValue, "cloneJsonValue");
+
+export {
+  appendImplicitDiscountLineItem
+};

package/dist/chunk-MV6LW5UB.js

@@ -0,0 +1,217 @@
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/promo/math.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+__name(round2, "round2");
+function grossFromNet(net, vatRate) {
+  return round2(net * (1 + vatRate / 100));
+}
+__name(grossFromNet, "grossFromNet");
+function computeIncludedVat(grossAmount, vatRate) {
+  return round2(grossAmount * vatRate / (100 + vatRate));
+}
+__name(computeIncludedVat, "computeIncludedVat");
+
+// src/billing/plan-catalog-from-snapshot.ts
+function buildPlanCatalogFromSnapshot(settings, snapshot) {
+  const liveByPlanKey = new Map(snapshot.livePlanVersions.map((v) => [
+    v.planId,
+    v
+  ]));
+  const plans = snapshot.plans.filter((p) => p.deletedAt === null).sort((a, b) => a.sortOrder - b.sortOrder).map((stem) => {
+    const live = liveByPlanKey.get(stem.planKey);
+    if (!live) {
+      return {
+        id: stem.planKey,
+        name: stem.label,
+        tagline: stem.description ?? void 0,
+        marketed: false,
+        monthlyNet: null,
+        yearlyNet: null,
+        features: [],
+        quotas: {}
+      };
+    }
+    return {
+      id: stem.planKey,
+      name: stem.label,
+      tagline: stem.description ?? void 0,
+      marketed: live.marketed,
+      monthlyNet: parseFloat(live.monthlyNet),
+      yearlyNet: parseFloat(live.yearlyNet),
+      features: live.features,
+      quotas: live.quotas ?? {}
+    };
+  });
+  const features = snapshot.featureEntries.filter((f) => f.deletedAt === null).sort((a, b) => a.sortOrder - b.sortOrder).map((row) => ({
+    key: row.featureKey,
+    label: row.label,
+    icon: row.icon ?? void 0,
+    tier: row.tier ?? void 0,
+    plannedOnly: row.plannedOnly
+  }));
+  return {
+    schemaVersion: 1,
+    projectKey: settings.projectKey,
+    ...settings.app ? {
+      app: settings.app
+    } : {},
+    currency: settings.currency,
+    vatRate: settings.vatRate,
+    ...settings.marketing ? {
+      marketing: settings.marketing
+    } : {},
+    features,
+    plans
+  };
+}
+__name(buildPlanCatalogFromSnapshot, "buildPlanCatalogFromSnapshot");
+
+// src/billing/plan-catalog.module.ts
+import { Module } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var PLAN_CATALOG_TOKEN = /* @__PURE__ */ Symbol("PLAN_CATALOG");
+var PLAN_CATALOG_READ_SINK_TOKEN = /* @__PURE__ */ Symbol("PLAN_CATALOG_READ_SINK");
+var PlanCatalogModule = class _PlanCatalogModule {
+  static {
+    __name(this, "PlanCatalogModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _PlanCatalogModule,
+      global: options.global ?? true,
+      imports: options.imports ?? [],
+      providers: [
+        ...options.extraProviders ?? [],
+        asProvider(PLAN_CATALOG_READ_SINK_TOKEN, options.sink),
+        {
+          provide: PLAN_CATALOG_TOKEN,
+          useFactory: /* @__PURE__ */ __name(async (sink) => {
+            const snapshot = await sink.loadSnapshot(options.projectKey);
+            return buildPlanCatalogFromSnapshot({
+              projectKey: options.projectKey,
+              app: options.app,
+              currency: options.currency,
+              vatRate: options.vatRate,
+              marketing: options.marketing
+            }, snapshot);
+          }, "useFactory"),
+          inject: [
+            PLAN_CATALOG_READ_SINK_TOKEN
+          ]
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_TOKEN,
+        PLAN_CATALOG_READ_SINK_TOKEN
+      ]
+    };
+  }
+  /**
+   * Tests / in-memory setup: takes the catalog object directly, without a
+   * sink/DB lookup. For unit tests + test bootstraps.
+   */
+  static forRootWithCatalog(catalog, opts = {}) {
+    return {
+      module: _PlanCatalogModule,
+      providers: [
+        {
+          provide: PLAN_CATALOG_TOKEN,
+          useValue: catalog
+        }
+      ],
+      exports: [
+        PLAN_CATALOG_TOKEN
+      ],
+      global: opts.global ?? true
+    };
+  }
+};
+PlanCatalogModule = _ts_decorate([
+  Module({})
+], PlanCatalogModule);
+
+// src/billing/plan-helpers.ts
+function findPlan(catalog, planId) {
+  return (catalog.plans ?? []).find((p) => p.id === planId);
+}
+__name(findPlan, "findPlan");
+function getPlanOrThrow(catalog, planId) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) {
+    throw new Error(`Plan "${planId}" nicht im Catalog (${catalog.projectKey}) gefunden`);
+  }
+  return plan;
+}
+__name(getPlanOrThrow, "getPlanOrThrow");
+function getMarketedPlans(catalog) {
+  return (catalog.plans ?? []).filter((p) => p.marketed !== false);
+}
+__name(getMarketedPlans, "getMarketedPlans");
+function getPlanPriceNet(catalog, planId, cycle) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) return null;
+  if (plan.marketed === false) return null;
+  const net = cycle === "YEARLY" ? plan.yearlyNet : plan.monthlyNet;
+  return net ?? null;
+}
+__name(getPlanPriceNet, "getPlanPriceNet");
+function getPlanPriceGross(catalog, planId, cycle, vatRate) {
+  const net = getPlanPriceNet(catalog, planId, cycle);
+  if (net === null) return null;
+  const rate = vatRate ?? catalog.vatRate;
+  return round2(net * (1 + rate / 100));
+}
+__name(getPlanPriceGross, "getPlanPriceGross");
+function isFeatureInPlan(catalog, planId, featureKey) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) return false;
+  return plan.features.includes(featureKey);
+}
+__name(isFeatureInPlan, "isFeatureInPlan");
+function getPlanQuota(catalog, planId, quotaKey) {
+  const plan = findPlan(catalog, planId);
+  return plan?.quotas[quotaKey];
+}
+__name(getPlanQuota, "getPlanQuota");
+function getActiveFeatureKeys(catalog) {
+  return (catalog.features ?? []).filter((f) => !f.plannedOnly).map((f) => f.key);
+}
+__name(getActiveFeatureKeys, "getActiveFeatureKeys");
+function isFeaturePlannedOnly(catalog, featureKey) {
+  const def = (catalog.features ?? []).find((f) => f.key === featureKey);
+  return def?.plannedOnly === true;
+}
+__name(isFeaturePlannedOnly, "isFeaturePlannedOnly");
+
+export {
+  round2,
+  grossFromNet,
+  computeIncludedVat,
+  buildPlanCatalogFromSnapshot,
+  PLAN_CATALOG_TOKEN,
+  PLAN_CATALOG_READ_SINK_TOKEN,
+  PlanCatalogModule,
+  findPlan,
+  getPlanOrThrow,
+  getMarketedPlans,
+  getPlanPriceNet,
+  getPlanPriceGross,
+  isFeatureInPlan,
+  getPlanQuota,
+  getActiveFeatureKeys,
+  isFeaturePlannedOnly
+};

package/dist/chunk-NYLON2VC.js

@@ -0,0 +1,6 @@
+// src/subscription-contract/tokens.ts
+var SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionContractRepository");
+
+export {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+};