@owlmeans/web-wl 0.1.2 → 0.1.4

package/README.md

@@ -1,744 +1,54 @@
 # @owlmeans/web-wl
 
-Web-specific whitelabeling functionality for OwlMeans Common Libraries. This package provides React components and browser-optimized services for implementing client-side whitelabeling, enabling web applications to dynamically customize branding, theming, and content based on entity-specific configurations.
+Web whitelabel — service factory, module declarations, and React components for managing whitelabel content in browser apps.
 
 ## Overview
 
-The `@owlmeans/web-wl` package serves as the web-specific implementation of the OwlMeans Whitelabeling Subsystem, designed for React-based frontend applications with focus on dynamic branding and user experience customization. It provides:
-
-- **Web Whitelabeling Service**: Browser-optimized service for loading and caching whitelabeling data
-- **React Components**: React components for whitelabel-aware UI elements
-- **Caching Strategy**: Efficient client-side caching of whitelabeling configurations
-- **API Integration**: Seamless integration with server-side whitelabeling providers
-- **Performance Optimization**: Optimized loading and rendering of dynamic branding content
-
-This package follows the OwlMeans "quadra" pattern as the **web** implementation, complementing:
-- **@owlmeans/wled**: Common whitelabeling declarations and base functionality *(base package)*
-- **@owlmeans/client-wl**: Base client whitelabeling functionality
-- **@owlmeans/server-wl**: Server-side whitelabeling implementation
-- **@owlmeans/web-wl**: Web browser whitelabeling implementation *(this package)*
+- `makeWlService(alias?)` — web-side whitelabel service factory
+- `wlModules` (exported as `modules`) — web-side whitelabel module declarations
+- Components for displaying whitelabel content
+- `DEFAULT_ALIAS` — `'wl-web-serivce'`
 
 ## Installation
 
 ```bash
-npm install @owlmeans/web-wl
+bun add @owlmeans/web-wl
 ```
 
-## Dependencies
-
-This package requires and integrates with:
-- `@owlmeans/wled`: Core whitelabeling types and modules
-- `@owlmeans/client`: Base client functionality
-- `@owlmeans/client-module`: Client module system for API calls
-- `@owlmeans/context`: Context management and service registration
-- React: Peer dependency for web components
-
-## Key Concepts
-
-### Web Whitelabeling Service
-Browser-optimized service that:
-- **Loads Whitelabeling Data**: Fetches entity-specific branding from server APIs
-- **Caches Configurations**: Implements client-side caching for performance
-- **Extracts Data**: Provides convenient access to specific whitelabeling data types
-- **Handles Errors**: Graceful error handling for failed whitelabeling requests
-
-### React Component Integration
-React components that automatically adapt to whitelabeling configurations:
-- **Dynamic Branding**: Components that change appearance based on entity branding
-- **Conditional Rendering**: Show/hide content based on whitelabeling rules
-- **Theme Integration**: Automatic theme switching based on entity configurations
-- **Performance**: Optimized rendering with minimal re-renders
+## Usage
 
-### Client-side Caching
-Efficient caching strategy:
-- **Memory Caching**: In-memory cache for frequently accessed configurations
-- **Cache Invalidation**: Smart cache invalidation strategies
-- **Performance**: Reduced API calls and improved user experience
-
-## API Reference
-
-### Factory Functions
-
-#### `makeWlService(alias?: string): WlWebService`
-
-Creates a web whitelabeling service instance with caching capabilities.
+Register the service and module declarations:
 
 ```typescript
-import { makeWlService } from '@owlmeans/web-wl'
+import { makeWlService, modules as wlModules } from '@owlmeans/web-wl'
 
-const wlService = makeWlService('main-wl')
-context.registerService(wlService)
+context.registerService(makeWlService())
+const modules = [...baseModules, ...wlModules, ...appModules]
 ```
 
-**Parameters:**
-- `alias`: Optional service alias (defaults to `DEFAULT_ALIAS`)
-
-**Returns:** `WlWebService` - Web whitelabeling service instance
+Downstream variants (e.g., `@owlmeans/web-wl-manager`) extend this with manager-store helpers like `setupWlManagerStore<C, T>(context)`.
 
-### Core Interfaces
+## API
 
-#### `WlWebService`
+### `makeWlService(alias?)`
 
-Web-specific whitelabeling service interface.
+Creates the web whitelabel service. `alias` defaults to `DEFAULT_ALIAS` (`'wl-web-serivce'`).
 
-```typescript
-interface WlWebService extends InitializedService {
-  load: (entityId: string) => Promise<ProvidedWLSet>
-  extract: <T>(key: string, set: ProvidedWLSet) => T | undefined
-}
-```
-
-**Methods:**
-
-**`load(entityId: string): Promise<ProvidedWLSet>`**
-- **Purpose**: Load complete whitelabeling data set for an entity
-- **Parameters**: `entityId` - Entity identifier
-- **Returns**: Promise resolving to whitelabeling data set
-- **Behavior**: 
-  - Checks cache first for existing data
-  - Makes API call to server if not cached
-  - Caches successful responses
-  - Returns comprehensive whitelabeling data
-
-**`extract<T>(key: string, set: ProvidedWLSet): T | undefined`**
-- **Purpose**: Extract specific whitelabeling data type from a data set
-- **Parameters**: 
-  - `key` - Provider key (e.g., 'company-provider', 'styles-provider')
-  - `set` - Whitelabeling data set
-- **Returns**: Extracted data of type T or undefined if not found
-- **Usage**: Convenient access to specific provider data
-
-#### `ProvidedWLSet`
-
-Collection of whitelabeling data from multiple providers.
-
-```typescript
-interface ProvidedWLSet<T extends Record<string, any> = Record<string, any>> {
-  [providerKey: string]: ProvidedWL<T>
-}
-```
+### `modules`
 
-#### `Config`
+Array of web-side module declarations for whitelabel content (re-exported as `wlModules` in downstream variants).
 
-Configuration interface for web whitelabeling.
+### Components
 
-```typescript
-interface Config extends ClientConfig {
-  // Inherits client configuration
-  // Plus whitelabeling-specific web settings
-}
-```
-
-#### `Context<C extends Config = Config>`
-
-Web context interface with whitelabeling support.
-
-```typescript
-interface Context<C extends Config = Config> extends ClientContext<C> {
-  // Inherits client context functionality
-  // With typed configuration for whitelabeling
-}
-```
-
-### React Components
-
-#### Whitelabeling Provider Component
-
-```typescript
-interface WlProviderProps {
-  entityId: string                    // Entity to load whitelabeling for
-  children: React.ReactNode          // Child components
-  fallback?: React.ReactNode         // Fallback content while loading
-  onError?: (error: Error) => void   // Error handler
-}
-
-const WlProvider: FC<WlProviderProps> = (props) => { /* ... */ }
-```
-
-#### Whitelabel-aware Components
-
-```typescript
-interface WlBrandProps {
-  entityId: string
-  type: 'square' | 'wide'           // Logo type
-  alt?: string                      // Alt text
-  fallback?: React.ReactNode        // Fallback if no logo
-}
-
-const WlBrand: FC<WlBrandProps> = (props) => { /* ... */ }
-
-interface WlThemeProps {
-  entityId: string
-  children: React.ReactNode
-}
-
-const WlTheme: FC<WlThemeProps> = (props) => { /* ... */ }
-```
+React components from `./components` (re-exported at root) for rendering whitelabel content.
 
 ### Constants
 
-#### `DEFAULT_ALIAS`
-
-Default service alias for whitelabeling service.
-
-```typescript
-const DEFAULT_ALIAS = 'wl-web-service'
-```
-
-## Usage Examples
-
-### Basic Web Whitelabeling Setup
-
-```typescript
-import { makeWlService } from '@owlmeans/web-wl'
-import { makeWebContext } from '@owlmeans/web-client'
-
-// Create web context
-const context = makeWebContext(config)
-
-// Create and register whitelabeling service
-const wlService = makeWlService()
-context.registerService(wlService)
-
-// Initialize context
-await context.configure().init()
-
-// Load whitelabeling data for an entity
-const entityId = 'company-123'
-const whitelabelData = await wlService.load(entityId)
-
-console.log('Whitelabeling data:', whitelabelData)
-```
-
-### React Component Integration
-
-```typescript
-import React, { useEffect, useState } from 'react'
-import { useContext } from '@owlmeans/client'
-import type { WlWebService, ProvidedWLSet } from '@owlmeans/web-wl'
-import type { CompanyInfo, CustomStyles, CustomMedia } from '@owlmeans/wled'
-
-interface WhitelabeledAppProps {
-  entityId: string
-  children: React.ReactNode
-}
-
-const WhitelabeledApp: React.FC<WhitelabeledAppProps> = ({ entityId, children }) => {
-  const context = useContext()
-  const [whitelabelData, setWhitelabelData] = useState<ProvidedWLSet | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<Error | null>(null)
-
-  useEffect(() => {
-    const loadWhitelabeling = async () => {
-      try {
-        setLoading(true)
-        const wlService = context.service<WlWebService>('wl-web-service')
-        const data = await wlService.load(entityId)
-        setWhitelabelData(data)
-      } catch (err) {
-        setError(err as Error)
-      } finally {
-        setLoading(false)
-      }
-    }
-
-    loadWhitelabeling()
-  }, [entityId, context])
-
-  if (loading) {
-    return <div>Loading branding...</div>
-  }
-
-  if (error) {
-    return <div>Error loading branding: {error.message}</div>
-  }
-
-  if (!whitelabelData) {
-    return <div>No branding data available</div>
-  }
-
-  // Extract specific whitelabeling data
-  const wlService = context.service<WlWebService>('wl-web-service')
-  const companyInfo = wlService.extract<CompanyInfo>('company-provider', whitelabelData)
-  const customStyles = wlService.extract<CustomStyles>('styles-provider', whitelabelData)
-  const customMedia = wlService.extract<CustomMedia>('media-provider', whitelabelData)
-
-  return (
-    <WhitelabelThemeProvider styles={customStyles}>
-      <div className="whitelabeled-app">
-        <header>
-          {customMedia?.brand?.wideLogo && (
-            <img 
-              src={customMedia.brand.wideLogo} 
-              alt={companyInfo?.fullName || 'Logo'} 
-              className="company-logo"
-            />
-          )}
-          <h1>{companyInfo?.fullName || 'Application'}</h1>
-        </header>
-        
-        <main>
-          {children}
-        </main>
-        
-        <footer>
-          <p>{companyInfo?.description}</p>
-        </footer>
-      </div>
-    </WhitelabelThemeProvider>
-  )
-}
-```
-
-### Dynamic Theme Application
-
-```typescript
-import React, { useMemo } from 'react'
-import { ThemeProvider, createTheme } from '@mui/material/styles'
-import type { CustomStyles } from '@owlmeans/wled'
-
-interface WhitelabelThemeProviderProps {
-  styles?: CustomStyles
-  children: React.ReactNode
-}
-
-const WhitelabelThemeProvider: React.FC<WhitelabelThemeProviderProps> = ({ 
-  styles, 
-  children 
-}) => {
-  const theme = useMemo(() => {
-    const baseTheme = createTheme()
-
-    if (!styles) {
-      return baseTheme
-    }
-
-    return createTheme({
-      ...baseTheme,
-      palette: {
-        ...baseTheme.palette,
-        primary: {
-          main: styles.colors.primaryColor,
-          contrastText: '#ffffff'
-        },
-        secondary: {
-          main: styles.colors.secondaryColor || baseTheme.palette.secondary.main
-        },
-        background: {
-          default: styles.colors.primaryBackground || baseTheme.palette.background.default,
-          paper: styles.colors.secondaryBackground || baseTheme.palette.background.paper
-        }
-      },
-      typography: {
-        ...baseTheme.typography,
-        fontFamily: styles.font.fontFamily || baseTheme.typography.fontFamily,
-        fontSize: styles.font.basicSize || baseTheme.typography.fontSize
-      }
-    })
-  }, [styles])
-
-  return (
-    <ThemeProvider theme={theme}>
-      {children}
-    </ThemeProvider>
-  )
-}
-```
-
-### Whitelabel-aware Components
-
-```typescript
-import React from 'react'
-import { useContext } from '@owlmeans/client'
-import type { WlWebService } from '@owlmeans/web-wl'
-import type { CustomMedia } from '@owlmeans/wled'
-
-interface CompanyLogoProps {
-  entityId: string
-  type?: 'square' | 'wide'
-  className?: string
-  alt?: string
-}
-
-const CompanyLogo: React.FC<CompanyLogoProps> = ({ 
-  entityId, 
-  type = 'wide', 
-  className,
-  alt = 'Company Logo'
-}) => {
-  const context = useContext()
-  const [logoUrl, setLogoUrl] = React.useState<string | null>(null)
-
-  React.useEffect(() => {
-    const loadLogo = async () => {
-      try {
-        const wlService = context.service<WlWebService>('wl-web-service')
-        const whitelabelData = await wlService.load(entityId)
-        const mediaData = wlService.extract<CustomMedia>('media-provider', whitelabelData)
-        
-        const logo = type === 'square' 
-          ? mediaData?.brand?.squareLogo 
-          : mediaData?.brand?.wideLogo
-          
-        setLogoUrl(logo || null)
-      } catch (error) {
-        console.error('Failed to load company logo:', error)
-        setLogoUrl(null)
-      }
-    }
-
-    loadLogo()
-  }, [entityId, type, context])
-
-  if (!logoUrl) {
-    return (
-      <div className={`company-logo-placeholder ${className || ''}`}>
-        {alt}
-      </div>
-    )
-  }
-
-  return (
-    <img 
-      src={logoUrl} 
-      alt={alt} 
-      className={`company-logo ${className || ''}`}
-    />
-  )
-}
-
-// Usage
-<CompanyLogo 
-  entityId="company-123" 
-  type="wide" 
-  className="header-logo"
-  alt="Acme Corporation"
-/>
-```
-
-### Custom Hook for Whitelabeling
-
-```typescript
-import { useState, useEffect } from 'react'
-import { useContext } from '@owlmeans/client'
-import type { WlWebService, ProvidedWLSet } from '@owlmeans/web-wl'
-
-interface UseWhitelabelResult<T = any> {
-  data: T | null
-  loading: boolean
-  error: Error | null
-  reload: () => void
-}
-
-export const useWhitelabel = <T = any>(
-  entityId: string, 
-  providerKey?: string
-): UseWhitelabelResult<T> => {
-  const context = useContext()
-  const [data, setData] = useState<T | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<Error | null>(null)
-
-  const loadData = async () => {
-    try {
-      setLoading(true)
-      setError(null)
-      
-      const wlService = context.service<WlWebService>('wl-web-service')
-      const whitelabelData = await wlService.load(entityId)
-      
-      if (providerKey) {
-        const extracted = wlService.extract<T>(providerKey, whitelabelData)
-        setData(extracted || null)
-      } else {
-        setData(whitelabelData as T)
-      }
-    } catch (err) {
-      setError(err as Error)
-      setData(null)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  useEffect(() => {
-    loadData()
-  }, [entityId, providerKey])
-
-  return {
-    data,
-    loading,
-    error,
-    reload: loadData
-  }
-}
-
-// Usage examples
-const CompanyInfoDisplay: React.FC<{ entityId: string }> = ({ entityId }) => {
-  const { data: companyInfo, loading, error } = useWhitelabel<CompanyInfo>(
-    entityId, 
-    'company-provider'
-  )
-
-  if (loading) return <div>Loading company info...</div>
-  if (error) return <div>Error: {error.message}</div>
-  if (!companyInfo) return <div>No company information available</div>
-
-  return (
-    <div>
-      <h2>{companyInfo.fullName}</h2>
-      <p>{companyInfo.description}</p>
-    </div>
-  )
-}
-
-const StylesDisplay: React.FC<{ entityId: string }> = ({ entityId }) => {
-  const { data: styles, loading, error } = useWhitelabel<CustomStyles>(
-    entityId, 
-    'styles-provider'
-  )
-
-  if (loading || error || !styles) return null
-
-  return (
-    <div style={{
-      backgroundColor: styles.colors.primaryBackground,
-      color: styles.colors.primaryColor,
-      fontFamily: styles.font.fontFamily
-    }}>
-      Custom styled content
-    </div>
-  )
-}
-```
-
-### Multi-entity Whitelabeling
-
-```typescript
-import React, { useState } from 'react'
-import { useWhitelabel } from './useWhitelabel'
-
-const MultiEntityDemo: React.FC = () => {
-  const [selectedEntity, setSelectedEntity] = useState('entity-1')
-  
-  const entities = [
-    { id: 'entity-1', name: 'Company A' },
-    { id: 'entity-2', name: 'Company B' },
-    { id: 'entity-3', name: 'Company C' }
-  ]
-
-  const { data: whitelabelData, loading } = useWhitelabel(selectedEntity)
-
-  return (
-    <div>
-      <select 
-        value={selectedEntity} 
-        onChange={(e) => setSelectedEntity(e.target.value)}
-      >
-        {entities.map(entity => (
-          <option key={entity.id} value={entity.id}>
-            {entity.name}
-          </option>
-        ))}
-      </select>
-
-      {loading ? (
-        <div>Loading whitelabel data...</div>
-      ) : (
-        <WhitelabeledApp entityId={selectedEntity}>
-          <div>Content for {selectedEntity}</div>
-        </WhitelabeledApp>
-      )}
-    </div>
-  )
-}
-```
-
-## Caching Strategy
-
-### Memory Cache Implementation
-
-```typescript
-// Internal caching implementation (simplified)
-class WhitelabelCache {
-  private cache = new Map<string, ProvidedWLSet>()
-  private ttl = 5 * 60 * 1000 // 5 minutes
-  private timestamps = new Map<string, number>()
-
-  set(entityId: string, data: ProvidedWLSet): void {
-    this.cache.set(entityId, data)
-    this.timestamps.set(entityId, Date.now())
-  }
-
-  get(entityId: string): ProvidedWLSet | undefined {
-    const timestamp = this.timestamps.get(entityId)
-    if (timestamp && Date.now() - timestamp > this.ttl) {
-      this.cache.delete(entityId)
-      this.timestamps.delete(entityId)
-      return undefined
-    }
-    return this.cache.get(entityId)
-  }
-
-  clear(): void {
-    this.cache.clear()
-    this.timestamps.clear()
-  }
-
-  invalidate(entityId: string): void {
-    this.cache.delete(entityId)
-    this.timestamps.delete(entityId)
-  }
-}
-```
-
-### Cache Management
-
-```typescript
-// Utility functions for cache management
-export const clearWhitelabelCache = (context: Context) => {
-  const wlService = context.service<WlWebService>('wl-web-service')
-  // Cache clearing would be implemented in the service
-}
-
-export const preloadWhitelabeling = async (
-  context: Context, 
-  entityIds: string[]
-) => {
-  const wlService = context.service<WlWebService>('wl-web-service')
-  
-  // Preload whitelabeling data for multiple entities
-  await Promise.all(
-    entityIds.map(entityId => wlService.load(entityId))
-  )
-}
-```
-
-## Error Handling
-
-### Graceful Error Handling
-
-```typescript
-const ErrorBoundaryWhitelabel: React.FC<{ 
-  children: React.ReactNode
-  fallback?: React.ReactNode 
-}> = ({ children, fallback }) => {
-  return (
-    <ErrorBoundary
-      fallback={fallback || <div>Failed to load branding</div>}
-      onError={(error) => {
-        console.error('Whitelabeling error:', error)
-        // Report to error tracking service
-      }}
-    >
-      {children}
-    </ErrorBoundary>
-  )
-}
-
-// Usage
-<ErrorBoundaryWhitelabel fallback={<DefaultBranding />}>
-  <WhitelabeledApp entityId={entityId}>
-    <AppContent />
-  </WhitelabeledApp>
-</ErrorBoundaryWhitelabel>
-```
-
-## Performance Optimization
-
-### Lazy Loading and Code Splitting
-
-```typescript
-import React, { lazy, Suspense } from 'react'
-
-// Lazy load whitelabel components
-const WhitelabeledDashboard = lazy(() => import('./WhitelabeledDashboard'))
-
-const App: React.FC = () => (
-  <Suspense fallback={<div>Loading...</div>}>
-    <WhitelabeledDashboard entityId="company-123" />
-  </Suspense>
-)
-```
-
-### Memoization
-
-```typescript
-import React, { memo, useMemo } from 'react'
-
-const MemoizedWhitelabelComponent = memo<{ entityId: string }>(({ entityId }) => {
-  const { data } = useWhitelabel(entityId, 'company-provider')
-  
-  const memoizedContent = useMemo(() => {
-    if (!data) return null
-    
-    return (
-      <div>
-        <h1>{data.fullName}</h1>
-        <p>{data.description}</p>
-      </div>
-    )
-  }, [data])
-
-  return memoizedContent
-})
-```
-
-## Integration with OwlMeans Ecosystem
-
-### Context Integration
-```typescript
-import { makeWebContext } from '@owlmeans/web-client'
-
-const context = makeWebContext(config)
-const wlService = context.service<WlWebService>('wl-web-service')
-```
-
-### Module System Integration
-```typescript
-import { modules } from '@owlmeans/web-wl'
-
-// Modules are automatically integrated via service
-context.registerService(wlService)
-```
-
-### Client Integration
-```typescript
-import { useContext } from '@owlmeans/client'
-
-const wlService = useContext().service<WlWebService>('wl-web-service')
-```
-
-## Best Practices
-
-1. **Caching**: Implement appropriate caching strategies for performance
-2. **Error Handling**: Provide graceful fallbacks for failed whitelabeling requests
-3. **Performance**: Use memoization and lazy loading for large applications
-4. **User Experience**: Show loading states during whitelabeling data fetch
-5. **Accessibility**: Ensure dynamic content maintains accessibility standards
-6. **Testing**: Test with different entity configurations and error scenarios
+- `DEFAULT_ALIAS` — `'wl-web-serivce'`
 
 ## Related Packages
 
-- **@owlmeans/wled**: Core whitelabeling types and modules
-- **@owlmeans/client-wl**: Base client whitelabeling functionality
-- **@owlmeans/server-wl**: Server-side whitelabeling implementation
-- **@owlmeans/client**: Base client functionality
-- **@owlmeans/client-module**: Client module system for API calls
-
-## TypeScript Support
-
-This package is written in TypeScript and provides full type safety:
-
-```typescript
-import type { 
-  WlWebService,
-  ProvidedWLSet,
-  Config,
-  Context
-} from '@owlmeans/web-wl'
-
-const wlService: WlWebService = makeWlService()
-const context: Context = makeWebContext(config)
-```
+- [`@owlmeans/wled`](../wled) — shared whitelabel types and constants
+- [`@owlmeans/client-wl`](../client-wl) — client-side whitelabel placeholder
+- [`@owlmeans/web-client`](../web-client) — base web context this service runs in
+- [`@owlmeans/web-panel`](../web-panel) — typical app-side `makeContext` foundation

package/build/modules.d.ts

@@ -1,3 +1,3 @@
-import type { ClientModule } from '@owlmeans/client-module';
-export declare const modules: ClientModule<unknown>[];
+import type { ClientEntrypoint } from '@owlmeans/client-entrypoint';
+export declare const modules: ClientEntrypoint<unknown>[];
 //# 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":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAK3D,eAAO,MAAM,OAAO,EAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,CAAA"}
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAKnE,eAAO,MAAM,OAAO,EAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAA"}

package/build/modules.js

@@ -1,4 +1,4 @@
-import { elevate } from '@owlmeans/client-module';
+import { elevate } from '@owlmeans/client-entrypoint';
 import { WL_PROVIDE, modules as wlModules } from '@owlmeans/wled';
 elevate(wlModules, WL_PROVIDE);
 export const modules = wlModules;

package/build/modules.js.map

@@ -1 +1 @@
-{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAEjD,OAAO,EAAE,UAAU,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;AAE9B,MAAM,CAAC,MAAM,OAAO,GAAG,SAAoC,CAAA"}
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;AAE9B,MAAM,CAAC,MAAM,OAAO,GAAG,SAAwC,CAAA"}

package/build/service.js

@@ -9,7 +9,7 @@ export const makeWlService = (alias = DEFAULT_ALIAS) => {
                 return cache[entityId];
             }
             const context = service.assertCtx();
-            const module = context.module(WL_PROVIDE);
+            const module = context.entrypoint(WL_PROVIDE);
             const [wlSet] = await module.call({ params: { entity: entityId } });
             return cache[entityId] = wlSet;
         },

package/build/service.js.map

@@ -1 +1 @@
-{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAG3C,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAgB,aAAa,EAAgB,EAAE;IAC3E,MAAM,KAAK,GAA0C,EAAE,CAAA;IAEvD,MAAM,OAAO,GAAiB,aAAa,CAAe,KAAK,EAAE;QAC/D,IAAI,EAAE,KAAK,EAAC,QAAQ,EAAC,EAAE;YACrB,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC5B,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAA;YACxB,CAAC;YAED,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,EAAmB,CAAA;YAEpD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAA8B,UAAU,CAAC,CAAA;YACtE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAA;YAEnE,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,KAA2B,CAAA;QACtD,CAAC;QAED,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;KAChC,CAAC,CAAA;IAEF,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA"}
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAG3C,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAgB,aAAa,EAAgB,EAAE;IAC3E,MAAM,KAAK,GAA0C,EAAE,CAAA;IAEvD,MAAM,OAAO,GAAiB,aAAa,CAAe,KAAK,EAAE;QAC/D,IAAI,EAAE,KAAK,EAAC,QAAQ,EAAC,EAAE;YACrB,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC5B,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAA;YACxB,CAAC;YAED,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,EAAmB,CAAA;YAEpD,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAkC,UAAU,CAAC,CAAA;YAC9E,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAA;YAEnE,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,KAA2B,CAAA;QACtD,CAAC;QAED,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;KAChC,CAAC,CAAA;IAEF,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/web-wl",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -21,18 +21,19 @@
     }
   },
   "dependencies": {
-    "@owlmeans/client": "^0.1.2",
-    "@owlmeans/client-module": "^0.1.2",
-    "@owlmeans/context": "^0.1.2",
-    "@owlmeans/wled": "^0.1.2"
+    "@owlmeans/client": "^0.1.4",
+    "@owlmeans/client-entrypoint": "^0.1.4",
+    "@owlmeans/context": "^0.1.4",
+    "@owlmeans/wled": "^0.1.4"
   },
   "peerDependencies": {
     "react": "*"
   },
   "devDependencies": {
+    "@owlmeans/dep-config": "workspace:*",
     "@types/react": "^19.2.7",
     "nodemon": "^3.1.11",
-    "typescript": "^5.8.3"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/modules.ts

@@ -1,8 +1,8 @@
 
-import { elevate } from '@owlmeans/client-module'
-import type { ClientModule } from '@owlmeans/client-module'
+import { elevate } from '@owlmeans/client-entrypoint'
+import type { ClientEntrypoint } from '@owlmeans/client-entrypoint'
 import { WL_PROVIDE, modules as wlModules } from '@owlmeans/wled'
 
 elevate(wlModules, WL_PROVIDE)
 
-export const modules = wlModules as ClientModule<unknown>[]
+export const modules = wlModules as ClientEntrypoint<unknown>[]

package/src/service.ts

@@ -1,4 +1,4 @@
-import type { ClientModule } from '@owlmeans/client-module'
+import type { ClientEntrypoint } from '@owlmeans/client-entrypoint'
 import { DEFAULT_ALIAS } from './consts.js'
 import type { Config, Context, ProvidedWLSet, WlWebService } from './types.js'
 import { createService } from '@owlmeans/context'
@@ -16,7 +16,7 @@ export const makeWlService = (alias: string = DEFAULT_ALIAS): WlWebService => {
 
       const context = service.assertCtx<Config, Context>()
 
-      const module = context.module<ClientModule<ProvidedWLSet>>(WL_PROVIDE)
+      const module = context.entrypoint<ClientEntrypoint<ProvidedWLSet>>(WL_PROVIDE)
       const [wlSet] = await module.call({ params: { entity: entityId } })
 
       return cache[entityId] = wlSet as ProvidedWLSet<any>

package/tsconfig.json

@@ -1,16 +1,11 @@
 {
   "extends": [
-    "../tsconfig.default.json",
-    "../tsconfig.react.json",
+    "@owlmeans/dep-config/tsconfig.base.json",
+    "@owlmeans/dep-config/tsconfig.react.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/**/*",
-    "./build/**/*",
-    "./*.ts"
-  ]
+  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
 }