digital-products 2.1.3 → 2.4.0

package/src/pricing/plans.ts

@@ -1,214 +0,0 @@
-/**
- * Pricing Plans
- * Product pricing and billing plans
- */
-
-/**
- * Billing interval
- */
-export type BillingInterval = 'monthly' | 'yearly' | 'custom'
-
-/**
- * Currency type
- */
-export type Currency = 'USD' | 'EUR' | 'GBP' | 'CAD' | 'AUD' | 'JPY' | string
-
-/**
- * Plan discount
- */
-export interface PlanDiscount {
-  percentage: number
-  monthlyEquivalent: number
-}
-
-/**
- * Trial configuration
- */
-export interface TrialConfig {
-  days: number
-  requiresPaymentMethod: boolean
-}
-
-/**
- * Usage-based pricing
- */
-export interface UsageBasedPricing {
-  metric: string
-  unitPrice: number
-  includedUnits: number
-}
-
-/**
- * Plan addon
- */
-export interface PlanAddon {
-  id: string
-  price: number
-  name?: string
-}
-
-/**
- * Pricing plan definition
- */
-export interface PricingPlanDefinition {
-  /** Unique identifier */
-  id: string
-  /** Human-readable name */
-  name: string
-  /** Associated tier ID */
-  tierId: string
-  /** Price */
-  price: number
-  /** Currency */
-  currency: Currency
-  /** Billing interval */
-  interval: BillingInterval
-  /** Custom interval in months */
-  intervalMonths?: number
-  /** Discount info */
-  discount?: PlanDiscount
-  /** Trial configuration */
-  trial?: TrialConfig
-  /** Usage-based pricing */
-  usageBased?: UsageBasedPricing
-  /** Available addons */
-  addons?: PlanAddon[]
-  /** Description */
-  description?: string
-  /** Metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Create a pricing plan
- */
-export function PricingPlan(config: PricingPlanDefinition): PricingPlanDefinition {
-  return {
-    id: config.id,
-    name: config.name,
-    tierId: config.tierId,
-    price: config.price,
-    currency: config.currency,
-    interval: config.interval,
-    intervalMonths: config.intervalMonths,
-    discount: config.discount,
-    trial: config.trial,
-    usageBased: config.usageBased,
-    addons: config.addons,
-    description: config.description,
-    metadata: config.metadata,
-  }
-}
-
-/**
- * Create and validate a pricing plan
- */
-export function createPricingPlan(config: PricingPlanDefinition): PricingPlanDefinition {
-  if (config.price < 0) {
-    throw new Error('Price must be non-negative')
-  }
-
-  if (config.interval === 'custom' && !config.intervalMonths) {
-    throw new Error('Custom interval requires intervalMonths')
-  }
-
-  return PricingPlan(config)
-}
-
-/**
- * Savings calculation result
- */
-export interface SavingsResult {
-  percentage: number
-  amount: number
-}
-
-/**
- * Plan registry interface
- */
-export interface PlanRegistry {
-  /** Register a plan */
-  register(plan: PricingPlanDefinition): void
-  /** Get a plan by ID */
-  get(id: string): PricingPlanDefinition | undefined
-  /** List all plans */
-  list(): PricingPlanDefinition[]
-  /** List plans by tier */
-  listByTier(tierId: string): PricingPlanDefinition[]
-  /** List plans by interval */
-  listByInterval(interval: BillingInterval): PricingPlanDefinition[]
-  /** Get monthly equivalent price */
-  getMonthlyEquivalent(planId: string): number
-  /** Calculate savings between plans */
-  calculateSavings(fromPlanId: string, toPlanId: string): SavingsResult
-  /** Clear registry */
-  clear(): void
-}
-
-/**
- * Create a plan registry
- */
-export function createPlanRegistry(): PlanRegistry {
-  const plans = new Map<string, PricingPlanDefinition>()
-
-  const getMonths = (plan: PricingPlanDefinition): number => {
-    if (plan.interval === 'monthly') return 1
-    if (plan.interval === 'yearly') return 12
-    return plan.intervalMonths ?? 1
-  }
-
-  return {
-    register(plan: PricingPlanDefinition): void {
-      plans.set(plan.id, plan)
-    },
-
-    get(id: string): PricingPlanDefinition | undefined {
-      return plans.get(id)
-    },
-
-    list(): PricingPlanDefinition[] {
-      return Array.from(plans.values())
-    },
-
-    listByTier(tierId: string): PricingPlanDefinition[] {
-      return Array.from(plans.values()).filter((p) => p.tierId === tierId)
-    },
-
-    listByInterval(interval: BillingInterval): PricingPlanDefinition[] {
-      return Array.from(plans.values()).filter((p) => p.interval === interval)
-    },
-
-    getMonthlyEquivalent(planId: string): number {
-      const plan = plans.get(planId)
-      if (!plan) return 0
-
-      const months = getMonths(plan)
-      return plan.price / months
-    },
-
-    calculateSavings(fromPlanId: string, toPlanId: string): SavingsResult {
-      const fromPlan = plans.get(fromPlanId)
-      const toPlan = plans.get(toPlanId)
-
-      if (!fromPlan || !toPlan) {
-        return { percentage: 0, amount: 0 }
-      }
-
-      const fromMonthly = fromPlan.price / getMonths(fromPlan)
-      const toMonthly = toPlan.price / getMonths(toPlan)
-
-      // Annualized comparison
-      const fromYearly = fromMonthly * 12
-      const toYearly = toMonthly * 12
-
-      const amount = fromYearly - toYearly
-      const percentage = (amount / fromYearly) * 100
-
-      return { percentage, amount }
-    },
-
-    clear(): void {
-      plans.clear()
-    },
-  }
-}

package/src/product.js

@@ -1,53 +0,0 @@
-/**
- * Generic Product() constructor
- */
-import { registry } from './registry.js';
-/**
- * Create a generic digital product definition
- *
- * @example
- * ```ts
- * const product = Product({
- *   id: 'my-product',
- *   name: 'My Product',
- *   description: 'A digital product',
- *   version: '1.0.0',
- * })
- * ```
- */
-export function Product(config) {
-    const product = {
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return product;
-}
-/**
- * Create and register a product in one step
- *
- * @example
- * ```ts
- * const product = createProduct({
- *   id: 'my-product',
- *   name: 'My Product',
- *   description: 'A digital product',
- *   version: '1.0.0',
- * })
- * ```
- */
-export function createProduct(config) {
-    const product = Product(config);
-    return product;
-}
-/**
- * Create and register any product definition
- */
-export function registerProduct(product) {
-    registry.register(product);
-    return product;
-}

package/src/registry.js

@@ -1,31 +0,0 @@
-/**
- * Product registry implementation
- */
-/**
- * In-memory product registry
- */
-class InMemoryProductRegistry {
-    products = new Map();
-    register(product) {
-        this.products.set(product.id, product);
-    }
-    get(id) {
-        return this.products.get(id);
-    }
-    list() {
-        return Array.from(this.products.values());
-    }
-    listByType(type) {
-        return this.list().filter((p) => p.type === type);
-    }
-    remove(id) {
-        return this.products.delete(id);
-    }
-    clear() {
-        this.products.clear();
-    }
-}
-/**
- * Global product registry instance
- */
-export const registry = new InMemoryProductRegistry();

package/src/sdk.js

@@ -1,127 +0,0 @@
-/**
- * SDK() - Define a software development kit
- */
-import { registerProduct } from './product.js';
-/**
- * Create an SDK definition
- *
- * @example
- * ```ts
- * const mySDK = SDK({
- *   id: 'my-sdk',
- *   name: 'My SDK',
- *   description: 'JavaScript SDK for My API',
- *   version: '1.0.0',
- *   language: 'typescript',
- *   api: 'my-api',
- *   exports: [
- *     Export('function', 'createClient', 'Create an API client', {
- *       parameters: {
- *         apiKey: 'API key for authentication',
- *         baseUrl: 'Optional base URL',
- *       },
- *       returns: 'API client instance',
- *     }),
- *     Export('class', 'APIClient', 'Main API client', {
- *       methods: [
- *         Export('function', 'get', 'GET request', {
- *           parameters: { path: 'Request path' },
- *           returns: 'Response data',
- *         }),
- *         Export('function', 'post', 'POST request', {
- *           parameters: { path: 'Request path', data: 'Request body' },
- *           returns: 'Response data',
- *         }),
- *       ],
- *     }),
- *   ],
- *   install: 'npm install my-sdk',
- *   examples: [
- *     Example(
- *       'Basic Usage',
- *       'Create a client and make a request',
- *       `import { createClient } from 'my-sdk'
- *
- * const client = createClient({ apiKey: 'YOUR_API_KEY' })
- * const users = await client.get('/users')
- * console.log(users)`
- *     ),
- *   ],
- * })
- * ```
- */
-export function SDK(config) {
-    const sdk = {
-        type: 'sdk',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        language: config.language,
-        api: config.api,
-        exports: config.exports,
-        install: config.install,
-        docs: config.docs,
-        examples: config.examples,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(sdk);
-}
-/**
- * Helper to create an SDK export
- *
- * @example
- * ```ts
- * const fn = Export('function', 'calculateTotal', 'Calculate order total', {
- *   parameters: {
- *     items: ['Array of order items'],
- *     taxRate: 'Tax rate (number)',
- *   },
- *   returns: 'Total amount (number)',
- * })
- *
- * const cls = Export('class', 'OrderManager', 'Manage orders', {
- *   methods: [
- *     Export('function', 'create', 'Create order', {
- *       parameters: { order: 'Order data' },
- *       returns: 'Created order',
- *     }),
- *   ],
- * })
- * ```
- */
-export function Export(type, name, description, options) {
-    return {
-        type,
-        name,
-        description,
-        parameters: options?.parameters,
-        returns: options?.returns,
-        methods: options?.methods,
-    };
-}
-/**
- * Helper to create an SDK example
- *
- * @example
- * ```ts
- * const example = Example(
- *   'Authentication',
- *   'How to authenticate with the API',
- *   `const client = createClient({
- *     apiKey: process.env.API_KEY,
- *   })`,
- *   '{ authenticated: true }'
- * )
- * ```
- */
-export function Example(title, description, code, output) {
-    return {
-        title,
-        description,
-        code,
-        output,
-    };
-}

package/src/site.js

@@ -1,112 +0,0 @@
-/**
- * Site() - Define a website
- */
-import { registerProduct } from './product.js';
-/**
- * Create a site definition
- *
- * @example
- * ```ts
- * const docsSite = Site({
- *   id: 'docs',
- *   name: 'Documentation Site',
- *   description: 'Product documentation',
- *   version: '1.0.0',
- *   generator: 'fumadocs',
- *   structure: {
- *     home: '/docs/index.mdx',
- *     docs: [
- *       '/docs/getting-started.mdx',
- *       '/docs/api-reference.mdx',
- *     ],
- *   },
- *   navigation: [
- *     Nav('Home', '/'),
- *     Nav('Docs', '/docs', {
- *       children: [
- *         Nav('Getting Started', '/docs/getting-started'),
- *         Nav('API Reference', '/docs/api-reference'),
- *       ],
- *     }),
- *   ],
- *   seo: {
- *     titleTemplate: '%s | My Product',
- *     description: 'Official documentation for My Product',
- *     keywords: ['docs', 'api', 'reference'],
- *   },
- *   analytics: {
- *     provider: 'plausible',
- *     id: 'docs.example.com',
- *   },
- * })
- * ```
- */
-export function Site(config) {
-    const site = {
-        type: 'site',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        generator: config.generator || 'next',
-        structure: config.structure,
-        navigation: config.navigation,
-        seo: config.seo,
-        analytics: config.analytics,
-        deployment: config.deployment,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(site);
-}
-/**
- * Helper to create a navigation item
- *
- * @example
- * ```ts
- * const nav = Nav('Documentation', '/docs', {
- *   icon: 'book',
- *   children: [
- *     Nav('Getting Started', '/docs/getting-started'),
- *     Nav('API Reference', '/docs/api'),
- *   ],
- * })
- * ```
- */
-export function Nav(label, href, options) {
-    return {
-        label,
-        href,
-        ...options,
-    };
-}
-/**
- * Helper to configure SEO
- *
- * @example
- * ```ts
- * const seo = SEO({
- *   titleTemplate: '%s | My Site',
- *   description: 'My awesome site',
- *   keywords: ['keyword1', 'keyword2'],
- *   ogImage: '/og-image.png',
- *   twitterCard: 'summary_large_image',
- * })
- * ```
- */
-export function SEO(config) {
-    return config;
-}
-/**
- * Helper to configure analytics
- *
- * @example
- * ```ts
- * const analytics = Analytics('google', 'G-XXXXXXXXXX')
- * const analytics = Analytics('plausible', 'example.com')
- * ```
- */
-export function Analytics(provider, id, config) {
-    return { provider, id, config };
-}

package/src/tiers/define.ts

@@ -1,137 +0,0 @@
-/**
- * Tier Definition
- * Product tier primitives
- */
-
-/**
- * Tier level type
- */
-export type TierLevel = number
-
-/**
- * Tier definition
- */
-export interface TierDefinition {
-  /** Unique identifier */
-  id: string
-  /** Human-readable name */
-  name: string
-  /** Tier level (higher = more features) */
-  level: TierLevel
-  /** Description */
-  description?: string
-  /** Custom pricing flag */
-  customPricing?: boolean
-  /** Feature limits */
-  limits?: Record<string, number | string>
-  /** Included features */
-  features?: string[]
-  /** Metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Create a tier definition
- */
-export function Tier(config: TierDefinition): TierDefinition {
-  return {
-    id: config.id,
-    name: config.name,
-    level: config.level,
-    description: config.description,
-    customPricing: config.customPricing,
-    limits: config.limits,
-    features: config.features,
-    metadata: config.metadata,
-  }
-}
-
-/**
- * Create and validate a tier definition
- */
-export function defineTier(config: TierDefinition): TierDefinition {
-  if (!config.id || config.id.trim() === '') {
-    throw new Error('Tier ID is required')
-  }
-
-  if (config.level < 0) {
-    throw new Error('Tier level must be non-negative')
-  }
-
-  return Tier(config)
-}
-
-/**
- * Tier registry interface
- */
-export interface TierRegistry {
-  /** Register a tier */
-  register(tier: TierDefinition): void
-  /** Get a tier by ID */
-  get(id: string): TierDefinition | undefined
-  /** List all tiers */
-  list(): TierDefinition[]
-  /** List tiers sorted by level */
-  listSorted(): TierDefinition[]
-  /** Compare two tiers */
-  compare(tierA: string, tierB: string): number
-  /** Check if tier has access to another tier's features */
-  hasAccessTo(currentTier: string, requiredTier: string): boolean
-  /** Get upgrade path from current tier */
-  getUpgradePath(currentTier: string): string[]
-  /** Clear registry */
-  clear(): void
-}
-
-/**
- * Create a tier registry
- */
-export function createTierRegistry(): TierRegistry {
-  const tiers = new Map<string, TierDefinition>()
-
-  return {
-    register(tier: TierDefinition): void {
-      tiers.set(tier.id, tier)
-    },
-
-    get(id: string): TierDefinition | undefined {
-      return tiers.get(id)
-    },
-
-    list(): TierDefinition[] {
-      return Array.from(tiers.values())
-    },
-
-    listSorted(): TierDefinition[] {
-      return Array.from(tiers.values()).sort((a, b) => a.level - b.level)
-    },
-
-    compare(tierA: string, tierB: string): number {
-      const a = tiers.get(tierA)
-      const b = tiers.get(tierB)
-      if (!a || !b) return 0
-      return a.level - b.level
-    },
-
-    hasAccessTo(currentTier: string, requiredTier: string): boolean {
-      const current = tiers.get(currentTier)
-      const required = tiers.get(requiredTier)
-      if (!current || !required) return false
-      return current.level >= required.level
-    },
-
-    getUpgradePath(currentTier: string): string[] {
-      const current = tiers.get(currentTier)
-      if (!current) return []
-
-      return Array.from(tiers.values())
-        .filter((t) => t.level > current.level)
-        .sort((a, b) => a.level - b.level)
-        .map((t) => t.id)
-    },
-
-    clear(): void {
-      tiers.clear()
-    },
-  }
-}