@owlmeans/wled 0.1.1 → 0.1.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+Copyright (c) 2026 OwlMeans Common — Fullstack typescript framework
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,489 +1,65 @@
 # @owlmeans/wled
 
-Base types and module declarations for the OwlMeans Common Whitelabeling Subsystem.
+Whitelabel ("wled") core — shared types, models, and module declarations for entity-specific branding/content.
 
 ## Overview
 
-The `@owlmeans/wled` package provides foundational types, constants, models, and modules for implementing whitelabeling functionality in OwlMeans applications. It serves as the core library for the OwlMeans Common Whitelabeling Subsystem, enabling applications to customize their appearance and branding dynamically.
-
-### Key Features
-
-- **Company Information Management** - Define and manage company branding details
-- **Custom Styling System** - Support for custom colors, fonts, and visual styling
-- **Media Management** - Handle custom brand assets like logos and media
-- **Validation Schemas** - AJV-based schemas for consistent data validation
-- **Route Integration** - Module definitions for whitelabeling API endpoints
-- **Type Safety** - Comprehensive TypeScript interfaces and types
-
-## Core Concepts
-
-### Whitelabeling Types
-
-The package defines several core types for whitelabeling:
-
-- **CompanyInfo** - Basic company information including name, slug, and description
-- **CustomStyles** - Visual styling configuration with colors and fonts
-- **CustomMedia** - Brand assets like logos and media files
-- **CustomUrls** - Custom URL configurations for different environments
-
-### Provider System
-
-The whitelabeling system uses a provider pattern where different types of whitelabeling data (company info, styles, media, DNS) can be requested and provided through a unified interface.
-
-### Validation Integration
-
-All data structures include corresponding AJV validation schemas, ensuring consistent validation across both frontend and backend implementations in fullstack applications.
+- `WL_PROVIDE` / `WL_PROVIDE_PATH` — module alias and path for the whitelabel provide endpoint
+- `WL_TYPE_COMPANY_INFO`, `WL_TYPE_STYLES`, `WL_TYPE_MEDIA`, `WL_TYPE_DNS` — whitelabel content type discriminators
+- Type definitions: `CompanyInfo`, `CustomStyles`, `CustomColors`, `CustomFont`, `CustomMedia`, `CustomBrand`, `ProvideParams`, `ProvidedWL<T>`
+- `modules` — array containing the `GET /wl/provide/:entity` declaration
+- AJV models under `model/` (e.g., `ProvideParamsSchema`)
 
 ## Installation
 
 ```bash
-npm install @owlmeans/wled
-```
-
-## API Reference
-
-### Types
-
-#### CompanyInfo
-Interface for company information in whitelabeling.
-
-```typescript
-interface CompanyInfo {
-  resource?: string     // Optional resource identifier
-  entityId: string      // Unique entity identifier
-  fullName: string      // Full company name
-  shortName: string     // Abbreviated company name
-  slug: string          // URL-friendly identifier
-  description: string   // Company description
-}
+bun add @owlmeans/wled
 ```
 
-#### CustomStyles
-Interface for custom styling configuration.
-
-```typescript
-interface CustomStyles {
-  resource?: string     // Optional resource identifier
-  entityId: string      // Unique entity identifier
-  font: CustomFont      // Font configuration
-  colors: CustomColors  // Color palette
-}
-```
+## Usage
 
-#### CustomColors
-Interface for custom color configuration.
+Use the shared module declarations and types when wiring server- and web-side whitelabel features:
 
 ```typescript
-interface CustomColors {
-  primaryColor: string           // Primary brand color (required)
-  secondaryColor?: string        // Secondary brand color
-  alertColor?: string            // Alert/error color
-  successColor?: string          // Success color
-  primaryBackground?: string     // Primary background color
-  secondaryBackground?: string   // Secondary background color
-  alertBackground?: string       // Alert background color
-  successBackground?: string     // Success background color
-}
+import { modules as wlModules } from '@owlmeans/wled'
+import type { ProvidedWL, CompanyInfo, CustomStyles } from '@owlmeans/wled'
 ```
 
-#### CustomFont
-Interface for custom font configuration.
+Reference content type discriminators when filtering whitelabel records:
 
 ```typescript
-interface CustomFont {
-  fontFamily: string    // Font family name
-  basicSize?: number    // Base font size (minimum 8)
-}
-```
+import { WL_TYPE_COMPANY_INFO, WL_TYPE_STYLES } from '@owlmeans/wled'
 
-#### CustomMedia
-Interface for custom media assets.
-
-```typescript
-interface CustomMedia {
-  brand: CustomBrand    // Brand asset configuration
-}
+const companyInfo = await wlResource.load(`${entityId}:${WL_TYPE_COMPANY_INFO}`)
 ```
 
-#### CustomBrand
-Interface for brand asset configuration.
-
-```typescript
-interface CustomBrand {
-  squareLogo?: string   // Square logo URL or path
-  wideLogo?: string     // Wide/horizontal logo URL or path
-}
-```
-
-#### CustomUrls
-Interface for custom URL configuration.
-
-```typescript
-interface CustomUrls {
-  adminUrl: string      // Admin panel URL
-  userUrl: string       // User interface URL
-}
-```
+The actual server handlers live in `@owlmeans/server-wl`; web UI in `@owlmeans/web-wl` / `@owlmeans/client-wl`.
 
-#### ProvideParams
-Interface for provider request parameters.
-
-```typescript
-interface ProvideParams {
-  entity: string        // Entity identifier to provide data for
-}
-```
-
-#### ProvidedWL
-Generic interface for provided whitelabeling data.
-
-```typescript
-type ProvidedWL<T extends {} = {}> = T & {
-  type: string          // Type identifier for the provided data
-  exists: boolean | null // Whether the data exists
-}
-```
+## API
 
 ### Constants
 
-#### Route Constants
-Constants for whitelabeling routes.
-
-```typescript
-const WL_PROVIDE = 'wl-provide'                    // Route alias
-const WL_PROVIDE_PATH = '/wl/provide/:entity'      // Route path pattern
-```
-
-#### Type Constants
-Constants for whitelabeling data types.
-
-```typescript
-const WL_TYPE_COMPANY_INFO = 'company-info'        // Company information type
-const WL_TYPE_STYLES = 'styles'                    // Styling configuration type
-const WL_TYPE_MEDIA = 'media'                      // Media assets type
-const WL_TYPE_DNS = 'dns'                          // DNS configuration type
-```
-
-### Validation Schemas
-
-The package includes AJV validation schemas for all data structures, ensuring consistent validation across fullstack applications.
-
-#### CompanyInfoSchema
-AJV schema for validating CompanyInfo data.
-
-```typescript
-const CompanyInfoSchema: JSONSchemaType<CompanyInfo> = {
-  type: 'object',
-  properties: {
-    resource: { type: 'string', minLength: 0, nullable: true },
-    entityId: { type: 'string', minLength: 1 },
-    fullName: { type: 'string', minLength: 1, maxLength: 128 },
-    shortName: { type: 'string', minLength: 0, maxLength: 32 },
-    slug: { type: 'string', minLength: 0 },
-    description: { type: 'string', minLength: 0, maxLength: 512 }
-  },
-  required: ['entityId', 'fullName', 'shortName', 'slug', 'description'],
-  additionalProperties: false
-}
-```
-
-#### CustomStylesSchema
-AJV schema for validating CustomStyles data.
-
-```typescript
-const CustomStylesSchema: JSONSchemaType<CustomStyles> = {
-  type: 'object',
-  properties: {
-    resource: { type: 'string', minLength: 0, nullable: true },
-    entityId: { type: 'string', minLength: 1 },
-    font: CustomFontSchema,
-    colors: CustomColorsSchema
-  },
-  required: ['entityId', 'font', 'colors'],
-  additionalProperties: false
-}
-```
-
-#### CustomColorsSchema
-AJV schema for validating CustomColors data.
-
-```typescript
-const CustomColorsSchema: JSONSchemaType<CustomColors> = {
-  type: 'object',
-  properties: {
-    primaryColor: { type: 'string', pattern: '^#(\\d|[a-fA-F]){3,8}$' },
-    secondaryColor: { type: 'string', pattern: '^#(\\d|[a-fA-F]){3,8}$', nullable: true },
-    // ... other color properties with hex color validation
-  },
-  required: ['primaryColor'],
-  additionalProperties: false
-}
-```
-
-#### CustomFontSchema
-AJV schema for validating CustomFont data.
+- `WL_PROVIDE` — `'wl-provide'`
+- `WL_PROVIDE_PATH` — `'/wl/provide/:entity'`
+- `WL_TYPE_COMPANY_INFO` — `'company-info'`
+- `WL_TYPE_STYLES` — `'styles'`
+- `WL_TYPE_MEDIA` — `'media'`
+- `WL_TYPE_DNS` — `'dns'`
 
-```typescript
-const CustomFontSchema: JSONSchemaType<CustomFont> = {
-  type: 'object',
-  properties: {
-    fontFamily: { type: 'string', minLength: 0, maxLength: 128 },
-    basicSize: { type: 'number', minimum: 8, nullable: true }
-  },
-  required: ['fontFamily'],
-  additionalProperties: false
-}
-```
-
-#### ProvideParamsSchema
-AJV schema for validating ProvideParams data.
-
-```typescript
-const ProvideParamsSchema: JSONSchemaType<ProvideParams> = {
-  type: 'object',
-  properties: {
-    entity: { type: 'string', minLength: 1 }
-  },
-  required: ['entity'],
-  additionalProperties: false
-}
-```
-
-### Modules
-
-#### Whitelabeling Provider Module
-Pre-configured module for handling whitelabeling data provision.
-
-```typescript
-import { modules } from '@owlmeans/wled'
-
-// The package exports a pre-configured module array
-const modules = [
-  module(
-    route(WL_PROVIDE, WL_PROVIDE_PATH, backend()),
-    filter(params(ProvideParamsSchema))
-  )
-]
-```
-
-This module provides:
-- Route configuration for `/wl/provide/:entity` endpoint
-- Parameter validation using the ProvideParamsSchema
-- Backend route configuration
-
-## Usage Examples
-
-### Basic Company Information
-
-```typescript
-import { CompanyInfo, WL_TYPE_COMPANY_INFO } from '@owlmeans/wled'
-
-// Create company information
-const companyInfo: CompanyInfo = {
-  entityId: 'company-123',
-  fullName: 'Example Corporation',
-  shortName: 'ExampleCorp',
-  slug: 'example-corp',
-  description: 'A leading technology company'
-}
-
-// Use with provider system
-const providedCompanyInfo: ProvidedWL<CompanyInfo> = {
-  ...companyInfo,
-  type: WL_TYPE_COMPANY_INFO,
-  exists: true
-}
-```
-
-### Custom Styling Configuration
-
-```typescript
-import { CustomStyles, CustomColors, CustomFont, WL_TYPE_STYLES } from '@owlmeans/wled'
-
-// Define custom colors
-const customColors: CustomColors = {
-  primaryColor: '#007bff',
-  secondaryColor: '#6c757d',
-  alertColor: '#dc3545',
-  successColor: '#28a745',
-  primaryBackground: '#ffffff',
-  secondaryBackground: '#f8f9fa'
-}
-
-// Define custom font
-const customFont: CustomFont = {
-  fontFamily: 'Inter, sans-serif',
-  basicSize: 14
-}
-
-// Create custom styles
-const customStyles: CustomStyles = {
-  entityId: 'company-123',
-  font: customFont,
-  colors: customColors
-}
-
-// Use with provider system
-const providedStyles: ProvidedWL<CustomStyles> = {
-  ...customStyles,
-  type: WL_TYPE_STYLES,
-  exists: true
-}
-```
-
-### Media Assets Configuration
-
-```typescript
-import { CustomMedia, CustomBrand, WL_TYPE_MEDIA } from '@owlmeans/wled'
-
-// Define brand assets
-const customBrand: CustomBrand = {
-  squareLogo: '/assets/logo-square.png',
-  wideLogo: '/assets/logo-wide.png'
-}
-
-// Create media configuration
-const customMedia: CustomMedia = {
-  brand: customBrand
-}
-
-// Use with provider system
-const providedMedia: ProvidedWL<CustomMedia> = {
-  ...customMedia,
-  type: WL_TYPE_MEDIA,
-  exists: true
-}
-```
-
-### Module Integration
-
-```typescript
-import { modules } from '@owlmeans/wled'
-import { context } from '@owlmeans/context'
-
-// Add whitelabeling modules to your application context
-context.modules.push(...modules)
-
-// The modules will handle requests to /wl/provide/:entity
-// with proper parameter validation
-```
-
-## Integration Patterns
-
-### Backend Integration
-
-```typescript
-import { modules, ProvideParams, CompanyInfo, WL_TYPE_COMPANY_INFO } from '@owlmeans/wled'
-
-// Register the whitelabeling provider module
-app.use(modules)
-
-// Implement handler for whitelabeling data provision
-const handleProvideWL = async (params: ProvideParams) => {
-  const { entity } = params
-  
-  // Fetch company information for the entity
-  const companyInfo = await getCompanyInfo(entity)
-  
-  if (companyInfo) {
-    return {
-      ...companyInfo,
-      type: WL_TYPE_COMPANY_INFO,
-      exists: true
-    }
-  }
-  
-  return {
-    type: WL_TYPE_COMPANY_INFO,
-    exists: false
-  }
-}
-```
-
-### Frontend Integration
-
-```typescript
-import { ProvideParams, ProvidedWL, CompanyInfo, WL_TYPE_COMPANY_INFO } from '@owlmeans/wled'
-
-// Fetch whitelabeling data from the provider endpoint
-const fetchWhitelabelingData = async (entity: string): Promise<ProvidedWL<CompanyInfo>> => {
-  const response = await fetch(`/wl/provide/${entity}`)
-  return response.json()
-}
-
-// Use in React component
-const WhitelabeledHeader = ({ entity }: { entity: string }) => {
-  const [companyInfo, setCompanyInfo] = useState<ProvidedWL<CompanyInfo> | null>(null)
-  
-  useEffect(() => {
-    fetchWhitelabelingData(entity).then(setCompanyInfo)
-  }, [entity])
-  
-  if (!companyInfo?.exists) {
-    return <DefaultHeader />
-  }
-  
-  return (
-    <header>
-      <h1>{companyInfo.fullName}</h1>
-      <p>{companyInfo.description}</p>
-    </header>
-  )
-}
-```
-
-### Multi-Type Provider Implementation
-
-```typescript
-import { 
-  ProvideParams, 
-  ProvidedWL, 
-  CompanyInfo, 
-  CustomStyles, 
-  CustomMedia,
-  WL_TYPE_COMPANY_INFO,
-  WL_TYPE_STYLES,
-  WL_TYPE_MEDIA
-} from '@owlmeans/wled'
+### Types
 
-// Generic provider that can handle different types
-const provideWhitelabelingData = async (
-  entity: string, 
-  type: string
-): Promise<ProvidedWL<any>> => {
-  switch (type) {
-    case WL_TYPE_COMPANY_INFO:
-      return await provideCompanyInfo(entity)
-    case WL_TYPE_STYLES:
-      return await provideCustomStyles(entity)
-    case WL_TYPE_MEDIA:
-      return await provideCustomMedia(entity)
-    default:
-      return { type, exists: false }
-  }
-}
-```
+`CompanyInfo`, `CustomStyles`, `CustomColors`, `CustomFont`, `CustomMedia`, `CustomBrand`, `ProvideParams`, `ProvidedWL<T>` — re-exported at the root entry.
 
-## Best Practices
+### `modules`
 
-1. **Consistent Validation** - Always use the provided AJV schemas to validate data on both frontend and backend
-2. **Type Safety** - Leverage TypeScript interfaces to ensure type safety throughout your application
-3. **Resource Management** - Use the optional `resource` field to track data sources and manage resources
-4. **Error Handling** - Always check the `exists` property in `ProvidedWL` responses before using the data
-5. **Hex Color Validation** - The color schemas enforce hex color format with proper validation patterns
-6. **Font Size Constraints** - Ensure font sizes meet the minimum requirement (8) when specified
-7. **Entity Identification** - Use consistent entity identifiers across all whitelabeling data types
+Array with one declaration: `GET /wl/provide/:entity` (alias `WL_PROVIDE`), with `params` filter using `ProvideParamsSchema`.
 
-## Dependencies
+### `model`
 
-This package depends on:
-- `@owlmeans/auth` - For authentication and entity validation schemas
-- `@owlmeans/module` - For module creation and filtering
-- `@owlmeans/route` - For route configuration
-- `ajv` - For JSON schema validation (peer dependency)
+Submodule exporting AJV schemas (e.g., `ProvideParamsSchema`) and helpers for whitelabel records.
 
 ## Related Packages
 
-- `@owlmeans/client-wl` - Client-side whitelabeling implementations
-- `@owlmeans/server-wl` - Server-side whitelabeling implementations
-- `@owlmeans/web-wl` - Web-specific whitelabeling components
+- [`@owlmeans/server-wl`](../server-wl) — server-side whitelabel handlers (uses `modules` from here)
+- [`@owlmeans/web-wl`](../web-wl) — web UI components for whitelabel content
+- [`@owlmeans/client-wl`](../client-wl) — client-side whitelabel placeholder

package/build/modules.d.ts

@@ -1,2 +1,2 @@
-export declare const modules: import("@owlmeans/module").CommonModule[];
+export declare const modules: import("@owlmeans/entrypoint").CommonEntrypoint[];
 //# sourceMappingURL=modules.d.ts.map

package/build/modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,2CAKnB,CAAA"}
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,mDAKnB,CAAA"}

package/build/modules.js

@@ -1,8 +1,8 @@
-import { filter, module, params } from '@owlmeans/module';
+import { filter, entrypoint, params } from '@owlmeans/entrypoint';
 import { route, backend } from '@owlmeans/route';
 import { WL_PROVIDE, WL_PROVIDE_PATH } from './consts.js';
 import { ProvideParamsSchema } from './model/provider.js';
 export const modules = [
-    module(route(WL_PROVIDE, WL_PROVIDE_PATH, backend()), filter(params(ProvideParamsSchema)))
+    entrypoint(route(WL_PROVIDE, WL_PROVIDE_PATH, backend()), filter(params(ProvideParamsSchema)))
 ];
 //# sourceMappingURL=modules.js.map

package/build/modules.js.map

@@ -1 +1 @@
-{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,MAAM,CACJ,KAAK,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,EAC7C,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CACpC;CACF,CAAA"}
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,UAAU,CACR,KAAK,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,EAC7C,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CACpC;CACF,CAAA"}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@owlmeans/wled",
-  "version": "0.1.1",
+  "version": "0.1.3",
+  "license": "MIT",
   "type": "module",
   "scripts": {
     "build": "tsc -b",
@@ -23,14 +24,15 @@
     "ajv": "*"
   },
   "dependencies": {
-    "@owlmeans/auth": "^0.1.1",
-    "@owlmeans/module": "^0.1.1",
-    "@owlmeans/route": "^0.1.1"
+    "@owlmeans/auth": "^0.1.3",
+    "@owlmeans/entrypoint": "^0.1.3",
+    "@owlmeans/route": "^0.1.3"
   },
   "devDependencies": {
+    "@owlmeans/dep-config": "workspace:*",
     "nodemon": "^3.1.11",
     "npm-check": "^6.0.1",
-    "typescript": "^5.8.3"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/modules.ts

@@ -1,10 +1,10 @@
-import { filter, module, params } from '@owlmeans/module'
+import { filter, entrypoint, params } from '@owlmeans/entrypoint'
 import { route, backend } from '@owlmeans/route'
 import { WL_PROVIDE, WL_PROVIDE_PATH } from './consts.js'
 import { ProvideParamsSchema } from './model/provider.js'
 
 export const modules = [
-  module(
+  entrypoint(
     route(WL_PROVIDE, WL_PROVIDE_PATH, backend()),
     filter(params(ProvideParamsSchema))
   )

package/tsconfig.json

@@ -1,11 +1,10 @@
 {
   "extends": [
-    "../tsconfig.default.json",
+    "@owlmeans/dep-config/tsconfig.base.json"
   ],
   "compilerOptions": {
-    "rootDir": "./src/", /* Specify the root folder within your source files. */
-    "outDir": "./build/", /* Specify an output folder for all emitted files. */
-    "moduleResolution": "Bundler",
+    "rootDir": "./src/",
+    "outDir": "./build/"
   },
   "exclude": [
     "./dist/**/*",