digital-products 2.0.1

package/test/product.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Tests for Product functionality
+ *
+ * Covers product creation and registration.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Product, createProduct, registerProduct, registry } from '../src/index.js'
+
+describe('Product', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('Product creation', () => {
+    it('creates a product with basic config', () => {
+      const product = Product({
+        id: 'my-product',
+        name: 'My Product',
+        description: 'A digital product',
+        version: '1.0.0',
+      })
+
+      expect(product.id).toBe('my-product')
+      expect(product.name).toBe('My Product')
+      expect(product.description).toBe('A digital product')
+      expect(product.version).toBe('1.0.0')
+    })
+
+    it('defaults status to active', () => {
+      const product = Product({
+        id: 'test',
+        name: 'Test',
+        description: 'Test product',
+        version: '1.0.0',
+      })
+
+      expect(product.status).toBe('active')
+    })
+
+    it('allows custom status', () => {
+      const product = Product({
+        id: 'test',
+        name: 'Test',
+        description: 'Test product',
+        version: '1.0.0',
+        status: 'deprecated',
+      })
+
+      expect(product.status).toBe('deprecated')
+    })
+
+    it('supports metadata', () => {
+      const product = Product({
+        id: 'test',
+        name: 'Test',
+        description: 'Test product',
+        version: '1.0.0',
+        metadata: { author: 'John', license: 'MIT' },
+      })
+
+      expect(product.metadata).toEqual({ author: 'John', license: 'MIT' })
+    })
+
+    it('supports tags', () => {
+      const product = Product({
+        id: 'test',
+        name: 'Test',
+        description: 'Test product',
+        version: '1.0.0',
+        tags: ['api', 'production'],
+      })
+
+      expect(product.tags).toEqual(['api', 'production'])
+    })
+  })
+
+  describe('createProduct', () => {
+    it('creates a product', () => {
+      const product = createProduct({
+        id: 'created-product',
+        name: 'Created Product',
+        description: 'A created product',
+        version: '1.0.0',
+      })
+
+      expect(product.id).toBe('created-product')
+      expect(product.name).toBe('Created Product')
+    })
+  })
+
+  describe('registerProduct', () => {
+    it('registers a product in the registry', () => {
+      const product = Product({
+        id: 'registered-product',
+        name: 'Registered',
+        description: 'Registered product',
+        version: '1.0.0',
+      })
+
+      registerProduct(product)
+
+      expect(registry.get('registered-product')).toBeDefined()
+    })
+
+    it('returns the registered product', () => {
+      const product = Product({
+        id: 'returned-product',
+        name: 'Returned',
+        description: 'Returned product',
+        version: '1.0.0',
+      })
+
+      const result = registerProduct(product)
+
+      expect(result).toBe(product)
+    })
+  })
+})
+
+describe('Registry', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('register', () => {
+    it('adds a product to the registry', () => {
+      const product = Product({
+        id: 'test-product',
+        name: 'Test',
+        description: 'Test',
+        version: '1.0.0',
+      })
+
+      registerProduct(product)
+
+      expect(registry.get('test-product')).toEqual(product)
+    })
+  })
+
+  describe('get', () => {
+    it('returns product by id', () => {
+      const product = Product({
+        id: 'get-test',
+        name: 'Get Test',
+        description: 'Test',
+        version: '1.0.0',
+      })
+
+      registerProduct(product)
+
+      expect(registry.get('get-test')?.name).toBe('Get Test')
+    })
+
+    it('returns undefined for non-existent id', () => {
+      expect(registry.get('non-existent')).toBeUndefined()
+    })
+  })
+
+  describe('list', () => {
+    it('returns all products', () => {
+      registerProduct(Product({ id: 'p1', name: 'P1', description: 'D1', version: '1.0.0' }))
+      registerProduct(Product({ id: 'p2', name: 'P2', description: 'D2', version: '1.0.0' }))
+
+      const products = registry.list()
+
+      expect(products).toHaveLength(2)
+    })
+
+    it('returns empty array when no products', () => {
+      expect(registry.list()).toHaveLength(0)
+    })
+  })
+
+  describe('remove', () => {
+    it('removes a product from the registry', () => {
+      registerProduct(Product({ id: 'to-remove', name: 'Remove', description: 'D', version: '1.0.0' }))
+
+      const result = registry.remove('to-remove')
+
+      expect(result).toBe(true)
+      expect(registry.get('to-remove')).toBeUndefined()
+    })
+
+    it('returns false for non-existent product', () => {
+      expect(registry.remove('non-existent')).toBe(false)
+    })
+  })
+
+  describe('clear', () => {
+    it('removes all products', () => {
+      registerProduct(Product({ id: 'p1', name: 'P1', description: 'D1', version: '1.0.0' }))
+      registerProduct(Product({ id: 'p2', name: 'P2', description: 'D2', version: '1.0.0' }))
+
+      registry.clear()
+
+      expect(registry.list()).toHaveLength(0)
+    })
+  })
+})

package/test/sdk.test.ts

@@ -0,0 +1,236 @@
+/**
+ * Tests for SDK functionality
+ *
+ * Covers SDK creation and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { SDK, Export, Example, registry } from '../src/index.js'
+
+describe('SDK', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('SDK creation', () => {
+    it('creates an SDK with basic config', () => {
+      const sdk = SDK({
+        id: 'my-sdk',
+        name: 'My SDK',
+        description: 'JavaScript SDK for My API',
+        version: '1.0.0',
+        language: 'typescript',
+      })
+
+      expect(sdk.id).toBe('my-sdk')
+      expect(sdk.name).toBe('My SDK')
+      expect(sdk.type).toBe('sdk')
+      expect(sdk.language).toBe('typescript')
+    })
+
+    it('creates an SDK with API reference', () => {
+      const sdk = SDK({
+        id: 'api-sdk',
+        name: 'API SDK',
+        description: 'SDK for API',
+        version: '1.0.0',
+        language: 'typescript',
+        api: 'my-api',
+      })
+
+      expect(sdk.api).toBe('my-api')
+    })
+
+    it('creates an SDK with exports', () => {
+      const sdk = SDK({
+        id: 'export-sdk',
+        name: 'Export SDK',
+        description: 'SDK with exports',
+        version: '1.0.0',
+        language: 'typescript',
+        exports: [
+          Export('function', 'createClient', 'Create an API client'),
+          Export('class', 'APIClient', 'Main API client'),
+        ],
+      })
+
+      expect(sdk.exports).toHaveLength(2)
+      expect(sdk.exports?.[0]?.name).toBe('createClient')
+    })
+
+    it('creates an SDK with install command', () => {
+      const sdk = SDK({
+        id: 'install-sdk',
+        name: 'Install SDK',
+        description: 'SDK with install command',
+        version: '1.0.0',
+        language: 'typescript',
+        install: 'npm install my-sdk',
+      })
+
+      expect(sdk.install).toBe('npm install my-sdk')
+    })
+
+    it('creates an SDK with docs URL', () => {
+      const sdk = SDK({
+        id: 'docs-sdk',
+        name: 'Docs SDK',
+        description: 'SDK with docs',
+        version: '1.0.0',
+        language: 'typescript',
+        docs: 'https://docs.example.com/sdk',
+      })
+
+      expect(sdk.docs).toBe('https://docs.example.com/sdk')
+    })
+
+    it('creates an SDK with examples', () => {
+      const sdk = SDK({
+        id: 'example-sdk',
+        name: 'Example SDK',
+        description: 'SDK with examples',
+        version: '1.0.0',
+        language: 'typescript',
+        examples: [
+          Example(
+            'Basic Usage',
+            'Create a client and make a request',
+            `import { createClient } from 'my-sdk'\nconst client = createClient({ apiKey: 'key' })`
+          ),
+        ],
+      })
+
+      expect(sdk.examples).toHaveLength(1)
+      expect(sdk.examples?.[0]?.title).toBe('Basic Usage')
+    })
+
+    it('registers SDK automatically', () => {
+      SDK({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+        language: 'typescript',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+
+    it('supports Python language', () => {
+      const sdk = SDK({
+        id: 'python-sdk',
+        name: 'Python SDK',
+        description: 'Python SDK',
+        version: '1.0.0',
+        language: 'python',
+        install: 'pip install my-sdk',
+      })
+
+      expect(sdk.language).toBe('python')
+    })
+  })
+
+  describe('Export helper', () => {
+    it('creates a function export', () => {
+      const exp = Export('function', 'createClient', 'Create an API client', {
+        parameters: {
+          apiKey: 'API key for authentication',
+          baseUrl: 'Optional base URL',
+        },
+        returns: 'API client instance',
+      })
+
+      expect(exp.type).toBe('function')
+      expect(exp.name).toBe('createClient')
+      expect(exp.description).toBe('Create an API client')
+      expect(exp.parameters?.apiKey).toBe('API key for authentication')
+      expect(exp.returns).toBe('API client instance')
+    })
+
+    it('creates a class export', () => {
+      const exp = 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',
+          }),
+        ],
+      })
+
+      expect(exp.type).toBe('class')
+      expect(exp.methods).toHaveLength(2)
+      expect(exp.methods?.[0]?.name).toBe('get')
+    })
+
+    it('creates a type export', () => {
+      const exp = Export('type', 'ClientOptions', 'Client configuration options', {
+        parameters: {
+          apiKey: 'API key',
+          timeout: 'Request timeout (number)',
+          retries: 'Number of retries (number)',
+        },
+      })
+
+      expect(exp.type).toBe('type')
+    })
+
+    it('creates a constant export', () => {
+      const exp = Export('constant', 'VERSION', 'SDK version string')
+
+      expect(exp.type).toBe('constant')
+      expect(exp.name).toBe('VERSION')
+    })
+  })
+
+  describe('Example helper', () => {
+    it('creates a basic example', () => {
+      const example = Example(
+        'Getting Started',
+        'How to get started with the SDK',
+        `import { SDK } from 'my-sdk'\nconst sdk = new SDK()`
+      )
+
+      expect(example.title).toBe('Getting Started')
+      expect(example.description).toBe('How to get started with the SDK')
+      expect(example.code).toContain('import')
+    })
+
+    it('creates an example with output', () => {
+      const example = Example(
+        'Authentication',
+        'How to authenticate',
+        `const client = createClient({ apiKey: 'key' })`,
+        '{ authenticated: true }'
+      )
+
+      expect(example.output).toBe('{ authenticated: true }')
+    })
+
+    it('creates a multi-line example', () => {
+      const code = `
+import { createClient } from 'my-sdk'
+
+const client = createClient({
+  apiKey: process.env.API_KEY,
+  baseUrl: 'https://api.example.com',
+})
+
+const users = await client.get('/users')
+console.log(users)
+`.trim()
+
+      const example = Example(
+        'Complete Example',
+        'Full usage example',
+        code
+      )
+
+      expect(example.code).toContain('createClient')
+      expect(example.code).toContain('console.log')
+    })
+  })
+})

package/test/site.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Tests for Site functionality
+ *
+ * Covers site creation and helper functions.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Site, Nav, SEO, Analytics, registry } from '../src/index.js'
+
+describe('Site', () => {
+  beforeEach(() => {
+    registry.clear()
+  })
+
+  describe('Site creation', () => {
+    it('creates a site with basic config', () => {
+      const site = Site({
+        id: 'docs',
+        name: 'Documentation Site',
+        description: 'Product documentation',
+        version: '1.0.0',
+      })
+
+      expect(site.id).toBe('docs')
+      expect(site.name).toBe('Documentation Site')
+      expect(site.type).toBe('site')
+    })
+
+    it('defaults generator to next', () => {
+      const site = Site({
+        id: 'default-gen',
+        name: 'Default Generator',
+        description: 'Uses default generator',
+        version: '1.0.0',
+      })
+
+      expect(site.generator).toBe('next')
+    })
+
+    it('supports fumadocs generator', () => {
+      const site = Site({
+        id: 'fumadocs-site',
+        name: 'Fumadocs Site',
+        description: 'Uses Fumadocs',
+        version: '1.0.0',
+        generator: 'fumadocs',
+      })
+
+      expect(site.generator).toBe('fumadocs')
+    })
+
+    it('creates a site with structure', () => {
+      const site = Site({
+        id: 'structured-site',
+        name: 'Structured Site',
+        description: 'Site with structure',
+        version: '1.0.0',
+        structure: {
+          home: '/docs/index.mdx',
+          docs: [
+            '/docs/getting-started.mdx',
+            '/docs/api-reference.mdx',
+          ],
+        },
+      })
+
+      expect(site.structure?.home).toBe('/docs/index.mdx')
+      expect(site.structure?.docs).toHaveLength(2)
+    })
+
+    it('creates a site with navigation', () => {
+      const site = Site({
+        id: 'navigated-site',
+        name: 'Navigated Site',
+        description: 'Site with navigation',
+        version: '1.0.0',
+        navigation: [
+          Nav('Home', '/'),
+          Nav('Docs', '/docs'),
+        ],
+      })
+
+      expect(site.navigation).toHaveLength(2)
+      expect(site.navigation?.[0]?.label).toBe('Home')
+    })
+
+    it('creates a site with SEO', () => {
+      const site = Site({
+        id: 'seo-site',
+        name: 'SEO Site',
+        description: 'Site with SEO',
+        version: '1.0.0',
+        seo: {
+          titleTemplate: '%s | My Product',
+          description: 'Official documentation',
+          keywords: ['docs', 'api'],
+        },
+      })
+
+      expect(site.seo?.titleTemplate).toBe('%s | My Product')
+      expect(site.seo?.keywords).toContain('docs')
+    })
+
+    it('creates a site with analytics', () => {
+      const site = Site({
+        id: 'analytics-site',
+        name: 'Analytics Site',
+        description: 'Site with analytics',
+        version: '1.0.0',
+        analytics: {
+          provider: 'plausible',
+          id: 'docs.example.com',
+        },
+      })
+
+      expect(site.analytics?.provider).toBe('plausible')
+      expect(site.analytics?.id).toBe('docs.example.com')
+    })
+
+    it('creates a site with deployment config', () => {
+      const site = Site({
+        id: 'deployed-site',
+        name: 'Deployed Site',
+        description: 'Site with deployment',
+        version: '1.0.0',
+        deployment: {
+          provider: 'vercel',
+          url: 'https://docs.example.com',
+        },
+      })
+
+      expect(site.deployment?.provider).toBe('vercel')
+    })
+
+    it('registers site automatically', () => {
+      Site({
+        id: 'auto-registered',
+        name: 'Auto Registered',
+        description: 'Automatically registered',
+        version: '1.0.0',
+      })
+
+      expect(registry.get('auto-registered')).toBeDefined()
+    })
+  })
+
+  describe('Nav helper', () => {
+    it('creates a basic nav item', () => {
+      const nav = Nav('Home', '/')
+
+      expect(nav.label).toBe('Home')
+      expect(nav.href).toBe('/')
+    })
+
+    it('creates a nav item with icon', () => {
+      const nav = Nav('Documentation', '/docs', {
+        icon: 'book',
+      })
+
+      expect(nav.icon).toBe('book')
+    })
+
+    it('creates a nav item with children', () => {
+      const nav = Nav('Docs', '/docs', {
+        children: [
+          Nav('Getting Started', '/docs/getting-started'),
+          Nav('API Reference', '/docs/api'),
+        ],
+      })
+
+      expect(nav.children).toHaveLength(2)
+      expect(nav.children?.[0]?.label).toBe('Getting Started')
+    })
+
+    it('creates nested navigation', () => {
+      const nav = Nav('Products', '/products', {
+        children: [
+          Nav('Apps', '/products/apps', {
+            children: [
+              Nav('Web', '/products/apps/web'),
+              Nav('Mobile', '/products/apps/mobile'),
+            ],
+          }),
+          Nav('APIs', '/products/apis'),
+        ],
+      })
+
+      expect(nav.children?.[0]?.children).toHaveLength(2)
+    })
+  })
+
+  describe('SEO helper', () => {
+    it('creates SEO config', () => {
+      const seo = SEO({
+        titleTemplate: '%s | My Site',
+        description: 'My awesome site',
+      })
+
+      expect(seo.titleTemplate).toBe('%s | My Site')
+      expect(seo.description).toBe('My awesome site')
+    })
+
+    it('creates SEO config with keywords', () => {
+      const seo = SEO({
+        keywords: ['keyword1', 'keyword2'],
+      })
+
+      expect(seo.keywords).toHaveLength(2)
+    })
+
+    it('creates SEO config with ogImage', () => {
+      const seo = SEO({
+        ogImage: '/og-image.png',
+        twitterCard: 'summary_large_image',
+      })
+
+      expect(seo.ogImage).toBe('/og-image.png')
+      expect(seo.twitterCard).toBe('summary_large_image')
+    })
+  })
+
+  describe('Analytics helper', () => {
+    it('creates Google analytics config', () => {
+      const analytics = Analytics('google', 'G-XXXXXXXXXX')
+
+      expect(analytics.provider).toBe('google')
+      expect(analytics.id).toBe('G-XXXXXXXXXX')
+    })
+
+    it('creates Plausible analytics config', () => {
+      const analytics = Analytics('plausible', 'example.com')
+
+      expect(analytics.provider).toBe('plausible')
+      expect(analytics.id).toBe('example.com')
+    })
+
+    it('creates analytics config with custom options', () => {
+      const analytics = Analytics('google', 'G-XXXXXXXXXX', {
+        anonymizeIp: true,
+      })
+
+      expect(analytics.config?.anonymizeIp).toBe(true)
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}