Lampa

https://github.com/yumata/lampa-source
Admin
Lampa is an open-source web application that serves as a media streaming platform with a modern...
Tokens:58,105
Snippets:709
Trust Score:7.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Create and Install a Plugin

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Develop a custom plugin by extending the base class, implementing an init method for registration, and then installing it into Lampa.

```javascript
class MyPlugin {
    constructor() {
        this.name = 'My Plugin'
        this.version = '1.0.0'
    }
    
    init() {
        console.log('Plugin loaded')
        
        // Register custom component
        Lampa.Component.add('plugin_screen', PluginComponent)
        
        // Add menu item
        Lampa.Menu.add('My Plugin', () => {
            Lampa.Router.call('plugin_screen', {})
        })
    }
}

// Install
Lampa.Plugins.install(new MyPlugin())
```

--------------------------------

### Manage Plugins and Marketplace

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

Enable or disable the installation of plugins and extensions, and control the visibility of the plugin marketplace. Set `plugins_use` to false to disallow installations and `plugins_store` to false to hide the marketplace.

```javascript
window.lampa_settings.plugins_use = false    // Disable plugins
window.lampa_settings.plugins_store = false  // Hide marketplace
```

--------------------------------

### Polling for Updates Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

Example of setting up a recurring timer to poll for new messages. It also shows how to later remove the polling timer using its function reference.

```javascript
// Poll for new messages every 10 seconds
Lampa.Timer.add(10000, () => {
    Lampa.Api.checkNewMessages(data => {
        if (data.count > 0) {
            Lampa.Notice.show('You have ' + data.count + ' new messages')
        }
    })
})

// Later, stop polling
const checkMessages = () => {
    // ...
}

Lampa.Timer.add(10000, checkMessages)
Lampa.Timer.remove(checkMessages)
```

--------------------------------

### Screen Transition Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

This pattern demonstrates how to manage screen transitions by hiding and destroying the current component before creating and showing a new one.

```javascript
// Current screen
let currentComponent = null

function switchToComponent(config) {
    // Hide current component
    if (currentComponent) {
        currentComponent.hide(() => {
            currentComponent.destroy()
        })
    }
    
    // Create and show new component
    currentComponent = Lampa.Component.create(config)
    $('main').html(currentComponent.render())
    currentComponent.show()
}

// Navigate to full content view
switchToComponent({
    component: 'full',
    id: 550,
    method: 'movie',
    card: movieData
})
```

--------------------------------

### Method Chaining for Listener Setup

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/subscribe.md

Illustrates how to chain multiple `add` calls to set up several event listeners consecutively. This provides a concise way to configure the listener instance.

```javascript
Lampa.Subscribe()
    .add('init', handleInit)
    .add('ready', handleReady)
    .add('error', handleError)
    .send('init', { version: '3.0' })
```

--------------------------------

### Basic Event Handling Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/subscribe.md

Demonstrates the fundamental usage of adding a listener and sending an event to trigger it. This pattern is suitable for simple event notifications.

```javascript
const listener = Lampa.Subscribe()

listener.add('start', () => {
    console.log('Application started')
})

listener.send('start')
```

--------------------------------

### Cleanup on Focus Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

Illustrates using the 'immediate' option to refresh content or sync with the server when the application regains focus. It also shows how to manually trigger a timer reset using Lampa.Timer.update().

```javascript
// Refresh everything when user returns to app
Lampa.Timer.add(30000, () => {
    refreshContent()
}, true)  // immediate = true

// Or manual refresh:
Lampa.Timer.add(60000, () => {
    syncWithServer()
})

// Force immediate sync when needed
Lampa.Timer.update()
```

--------------------------------

### Get and Set Content Source

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

Demonstrates how to retrieve the current content source from localStorage and how to change it to a different source like 'cub'.

```javascript
// Get current source
const source = Lampa.Storage.get('source', 'tmdb')

// Change source
Lampa.Storage.set('source', 'cub')
```

--------------------------------

### Correcting Lampa.Empty Instance Binding

Source: https://github.com/yumata/lampa-source/blob/main/UPGRADE.md

Shows the necessary correction for the 'Lampa.Empty' class when transitioning, specifically binding the 'start' method to its instance.

```javascript
// было
let empty = new Lampa.Empty()
this.start = empty.start

// стало
let empty = new Lampa.Empty()
this.start = empty.start.bind(empty)
```

--------------------------------

### Modify Runtime Settings and Listen for Changes

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

This example shows how to change Lampa settings like theme or notifications after the application has loaded using Lampa.Storage.set. It also demonstrates how to follow changes to specific settings.

```javascript
// In console or plugin
Lampa.Storage.set('theme', 'light')
Lampa.Storage.set('notifications', true)

// Listen for setting changes
Lampa.Storage.listener.follow('change', (event) => {
    if (event.name === 'source') {
        console.log('Content source changed to:', event.value)
    }
})
```

--------------------------------

### Create a Card Component

Source: https://github.com/yumata/lampa-source/blob/main/UPGRADE.md

Example of creating a simplified card with a title and click handler using Lampa.Maker.make. It demonstrates importing specific modules and using the 'use' method for event handling.

```javascript
let card = Lampa.Maker.make('Card', {
    title: '...',
}, (module)=>module.only('Create', 'Callback'))

card.use({
    onFocus: function(){
        Background.change(Utils.cardImgBackground(this.data))
    },
    onEnter: function(){
        Router.call('full', this.data)
    }
})
```

--------------------------------

### Create Subscribe Instance

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/subscribe.md

Instantiates a new Subscribe object for managing event listeners. This is the starting point for all subscription operations.

```javascript
const listener = Subscribe()

```

--------------------------------

### Storage Methods

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/INDEX.md

Provides methods for interacting with storage, including getting, setting, adding, and managing data.

```APIDOC
## Storage Methods

### Description
Provides methods for interacting with storage, including getting, setting, adding, and managing data.

### Methods
- `Storage.get`
- `Storage.set`
- `Storage.add`
- `Storage.field`
- `Storage.cache`
- `Storage.sync`
- `Storage.remove`
- `Storage.clean`
- `Storage.clear`
- `Storage.getsize`
- `Storage.task`
```

--------------------------------

### get

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Retrieves a value from storage with automatic type conversion. Supports default values for non-existent keys.

```APIDOC
## get

### Description
Retrieves a value from storage with automatic type conversion.

### Method
`get(name: string, empty?: any): any`

### Parameters
#### Path Parameters
- **name** (string) - Required - Storage key name
- **empty** (any) - Optional - Default value if key not found

### Returns
The stored value with automatic type conversion (boolean, number, object, array, or string)

### Example
```javascript
// Get a stored value
const theme = Lampa.Storage.get('theme', 'dark')

// Get complex object
const settings = Lampa.Storage.get('user_settings', {})

// Get array
const history = Lampa.Storage.get('search_history', [])

// Get boolean
const enabled = Lampa.Storage.get('notifications', false)
```
```

--------------------------------

### Using 'createInstance' and 'emit' in Params

Source: https://github.com/yumata/lampa-source/blob/main/UPGRADE.md

Example showing how to use 'createInstance' to instantiate custom classes like 'CardParser' or 'Episode' and 'emit' for event subscriptions within the 'params' object.

```javascript
{
    title: '...',
    results: [
        {
            title: '...',
            params: {
                // создаем экземпляр класса CardParser
                createInstance: (item_data)=> Lampa.Maker.make('CardParser', item_data) 
            }
        },
        {
            title: '...',
            params: {
                // создаем экземпляр класса Episode с модулями Line и Callback
                createInstance: (item_data)=> Lampa.Maker.make('Episode', item_data, (module)=>module.only('Line','Callback')),

                // подписываемся на события
                emit: {
                    
                    onFocus: function(){
                        ...
                    },
                    // приоритетный обработчик события onEnter
                    onlyEnter: function(){
                        ...
                    }
                }
            }
        }
    ],

    // параметры для класса Line
    icon_svg: Template.string('icon_fire'),
    icon_bgcolor: '#fff',
    icon_color: '#fd4518',

    params: {
        // включаем модуль Icon для класса Line
        module: Lampa.Maker.module('Line').toggle('Icon') 
    }
}
```

--------------------------------

### Retrieve User Preferences from Local Storage

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

This example shows how to retrieve various user preferences, such as content source, UI theme, and language, which are stored in the browser's localStorage.

```javascript
// User settings stored here
Lampa.Storage.get('source')              // Content source
Lampa.Storage.get('theme')               // UI theme
Lampa.Storage.get('language')            // Interface language
Lampa.Storage.get('notifications')       // Enable notifications
Lampa.Storage.get('advanced_animation')  // Animation settings
```

--------------------------------

### Component Interface Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/emit.md

Defines the structure for components interacting with the Emit system. Components implement event handler methods such as `onInitialize`, `onUpdate`, and `onlyActivate`.

```javascript
class MyComponent {
    constructor(emit) {
        this.emit = emit
    }
    
    // Global event handlers (all components can implement)
    onInitialize(data) {
        console.log('Component initialized')
    }
    
    onUpdate(data) {
        console.log('Updated with:', data)
    }
    
    // Exclusive handler (only one component implements)
    onlyActivate() {
        console.log('This component activated (exclusive)')
        return true
    }
    
    // Not all components need to implement all handlers
}
```

--------------------------------

### Create Emit Instance

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/emit.md

Instantiates a new Emit object to manage component events. This is the starting point for using the Emit system.

```javascript
const emit = new Emit()
```

--------------------------------

### Passing Module Parameters

Source: https://github.com/yumata/lampa-source/blob/main/UPGRADE.md

Shows how to pass parameters to specific modules within the 'params' object, using 'items' as an example for the 'Items' module.

```javascript
{
    title: '...',
    results: [
        {
            title: '...',
            params: {
                // параметры для модуля Items
                items: {
                    mapping: 'line',
                    align_left: false,
                    view: 7
                }
            }
        }
    ],

    params: {
        ...
    }
}
```

--------------------------------

### Get and Render Card Template

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Retrieves a pre-compiled HTML template for a card and renders it with provided data. Ensure the 'card' template is registered.

```javascript
const card = Lampa.Template.get('card')
const rendered = Lampa.Template.js('card', data)
```

--------------------------------

### Documentation Standards for API Methods

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/INDEX.md

Each API method documentation includes its signature, parameter details, return type, example code, usage patterns, and related classes/methods.

```markdown
Method Signature
├── Parameter Details Table
├── Return Type & Description
├── Example Code (usually 2-3)
├── Usage Patterns (if applicable)
└── Related Classes/Methods
```

--------------------------------

### Setup Recurring Tasks with Lampa Timer

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Lampa.Timer enables scheduling recurring tasks at specified intervals (in milliseconds) and removing them when no longer needed.

```javascript
// Refresh every 30 seconds
Lampa.Timer.add(30000, () => {
    console.log('Refresh')
    loadNewContent()
})

// Poll for notifications every 10 seconds
const checkNotifications = () => {
    console.log('Checking...')
}

Lampa.Timer.add(10000, checkNotifications)

// Later, remove timer
Lampa.Timer.remove(checkNotifications)
```

--------------------------------

### YouTube Bridge JavaScript Logic

Source: https://github.com/yumata/lampa-source/blob/main/public/youtube.html

Handles YouTube player initialization, event handling, and communication with the parent window using postMessage. Includes functions for getting URL parameters, sending messages, and managing player state.

```javascript
function gup(name, url){ if(!url) url = location.href
name = name.replace(/[\[\]]/,"\\\\[").replace(/[\[\]]/,"\\\\]")
var regexS = "[\\?&]" + name + "=(\\[^&#]\\[*)"
var regex = new RegExp(regexS)
var results = regex.exec(url)
return results == null ? null : results[1]
}

var bridgeId = gup('bridgeId') || ''
var videoId = gup('videoId') || ''
var autoplay = Number(gup('autoplay') || '1')
var controls = Number(gup('controls') || '1')
var mute = Number(gup('mute') || '0')
var start = Number(gup('start') || '0')

var player = null
var ready = false
var timer = null
var screen_size = 2

function send(type, data){
    if(typeof data === 'undefined') data = {}
    try{
        parent.postMessage({ bridgeId: bridgeId, type: type, data: data }, '*')
    } catch(e){}
}

function tick(){
    if(!player || !ready) return
    try{
        send('time', { currentTime: player.getCurrentTime(), duration: player.getDuration(), playerState: player.getPlayerState(), playbackQuality: player.getPlaybackQuality ? player.getPlaybackQuality() : '' })
    } catch(e){}
}

function startTimer(){
    stopTimer()
    timer = setInterval(tick, 100)
}

function stopTimer(){
    if(timer){
        clearInterval(timer)
        timer = null
    }
}

function resize(){
    var width = window.innerWidth * screen_size
    var height = (window.innerHeight + 600) * screen_size
    var iframe = document.getElementById('player')
    if(iframe){
        iframe.style.width = width + 'px'
        iframe.style.height = height + 'px'
    }
}

window.onYouTubeIframeAPIReady = function(){
    player = new YT.Player('player', {
        videoId: videoId,
        width: '100%',
        height: '100%',
        playerVars: {
            autoplay: autoplay,
            controls: controls,
            mute: mute,
            start: start,
            rel: 0,
            modestbranding: 1,
            playsinline: 1,
            enablejsapi: 1,
            origin: location.origin
        },
        events: {
            onReady: function(){
                ready = true
                send('ready')
                tick()
                startTimer()
            },
            onStateChange: function(event){
                send('stateChange', { state: event.data })
            },
            onPlaybackQualityChange: function(event){
                send('qualityChange', { quality: event.data })
            },
            onError: function(event){
                send('error', { error: event.data })
            }
        }
    })
    resize()
}

window.addEventListener('message', function(event){
    if(!event.data || event.data.bridgeId !== bridgeId) return

    var type = event.data.type
    var data = event.data.data

    if(type === 'init'){
        if(player && ready && typeof data.volume === 'number'){
            try{
                player.setVolume(data.volume)
            } catch(e){}
        }
        return
    }

    if(!player || !ready) return

    try{
        if(type === 'play'){
            player.playVideo()
        } else if(type === 'pause'){
            player.pauseVideo()
        } else if(type === 'seekTo'){
            player.seekTo(data.time, true)
        } else if(type === 'setVolume'){
            player.setVolume(data.volume)
        } else if(type === 'resize'){
            resize()
            if(typeof player.setSize === 'function'){
                player.setSize(data.width, data.height)
            }
        } else if(type === 'setPlaybackRate'){
            if(typeof player.setPlaybackRate === 'function'){
                player.setPlaybackRate(data.rate)
            }
        } else if(type === 'destroy'){
            stopTimer()
            try{
                player.destroy()
            } catch(e){}
            player = null
            ready = false
        }
        tick()
    } catch(e){}
})

send('bridgeReady')
```

--------------------------------

### Get Available Discovery Sources

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/api.md

Retrieves a list of available discovery sources for the main page. The active source is prioritized first in the returned array.

```javascript
const discoveries = Lampa.Api.availableDiscovery()
discoveries.forEach(discovery => {
    console.log('Available discovery:', discovery)
})
```

--------------------------------

### Approximate Timer Interval Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

This callback will execute approximately every 10 seconds. Lampa.Timer provides an approximate interval, with checks happening periodically.

```javascript
// This callback will execute every ~10 seconds
// Not exactly 10 seconds, but within ±1 second
Lampa.Timer.add(10000, () => {
    console.log('~10 second interval')
})
```

--------------------------------

### Store and Retrieve Data with Lampa Storage

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Use Lampa.Storage to set, get, and manage data. It supports default values, adding items to arrays without duplicates, and listening for storage changes.

```javascript
// Save user preference
Lampa.Storage.set('theme', 'dark')
Lampa.Storage.set('notifications', true)
Lampa.Storage.set('user_data', { id: 123, name: 'John' })

// Retrieve with default
const theme = Lampa.Storage.get('theme', 'light')
const settings = Lampa.Storage.get('user_data', {})

// Add to array (no duplicates)
if (Lampa.Storage.add('favorites', movieId)) {
    console.log('Added to favorites')
}

// Listen for changes
Lampa.Storage.listener.follow('change', (event) => {
    console.log('Changed:', event.name, '=', event.value)
})
```

--------------------------------

### Automatic Pause/Resume Example

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

Demonstrates the automatic pause and resume behavior. When the application tab is hidden, timers are paused. Upon returning to the tab, timers resume, but callbacks execute only once, preventing a backlog of executions.

```javascript
// App has timer
Lampa.Timer.add(5000, () => {
    console.log('Tick')
})

// User switches to another tab (30 seconds pass)
// No "Tick" logs are printed during this time

// User returns to tab
// Timers unpause, callback only executes once
// Not 6 times (30s / 5s)
```

--------------------------------

### Render Templates with Lampa Template

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Use Lampa.Template to get existing template elements, render them with data using JavaScript templating, and insert the rendered output into the DOM. Custom templates can also be registered.

```javascript
// Get template element
const card = Lampa.Template.get('card')

// Render template with data
const rendered = Lampa.Template.js('card', {
    id: 550,
    title: 'Fight Club',
    poster_path: '/poster.jpg',
    vote_average: 8.8
})

// Insert into page
document.querySelector('.content').appendChild(rendered)

// Register custom template
Lampa.Template.add('my_template', '<div>{{ title }}</div>')
```

--------------------------------

### Show Player with Options

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Initiates the video player with specified options. This is the main entry point for playback.

```javascript
Lampa.Player.show(options)
```

--------------------------------

### get

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Retrieves a compiled template by name and returns a rendered DOM element. This is useful for getting a clone of a template that can be directly inserted into the DOM.

```APIDOC
## get

### Description
Retrieves a compiled template by name and returns a rendered DOM element. This is useful for getting a clone of a template that can be directly inserted into the DOM.

### Method
```javascript
get(name: string): jQuery | HTMLElement
```

### Parameters
#### Path Parameters
- **name** (string) - Required - Template identifier

### Response
#### Success Response
- Returns a jQuery element (clone of template) ready for insertion into DOM.

### Request Example
```javascript
// Get UI component templates
const header = Lampa.Template.get('head')
const menu = Lampa.Template.get('menu')
const modal = Lampa.Template.get('modal')
const card = Lampa.Template.get('card')

// Get player templates
const player = Lampa.Template.get('player')
const playerPanel = Lampa.Template.get('player_panel')
const playerVideo = Lampa.Template.get('player_video')
```
```

--------------------------------

### Get UI Component Templates

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Retrieves pre-compiled UI component templates by name. Use this to get template elements for common UI parts like headers, menus, modals, and cards.

```javascript
const header = Lampa.Template.get('head')
const menu = Lampa.Template.get('menu')
const modal = Lampa.Template.get('modal')
const card = Lampa.Template.get('card')

// Get player templates
const player = Lampa.Template.get('player')
const playerPanel = Lampa.Template.get('player_panel')
const playerVideo = Lampa.Template.get('player_video')
```

--------------------------------

### shuffleArrayFromIndex

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/arrays.md

Shuffles array elements starting from a specified index. Modifies the array in-place.

```APIDOC
## shuffleArrayFromIndex

### Description
Shuffles array elements starting from specified index.

### Parameters
#### Path Parameters
- **array** (array) - Required - Array to shuffle
- **startIndex** (number) - Required - Index to start shuffling from

### Returns
`undefined` (modifies in-place)

### Example
```javascript
const list = ['a', 'b', 'c', 'd', 'e']
Lampa.Arrays.shuffleArrayFromIndex(list, 2)
// list = ['a', 'b', 'e', 'd', 'c'] (only from index 2 shuffled)
```
```

--------------------------------

### Initialize Lampa with Custom Configuration

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

This HTML script block shows how to set custom Lampa configurations before the main 'lampa.js' script is loaded. It includes various settings like socket usage, account integration, and feature flags.

```html
<script>
// Set custom configuration
window.lampa_settings = {
    socket_use: true,
    account_use: true,
    plugins_use: true,
    torrents_use: true,
    
    disable_features: {
        dmca: false,
        lgbt: false,
        reactions: false,
        discuss: false,
        ai: false,
        subscribe: false,
        blacklist: false,
        persons: false,
        ads: false,
        trailers: false,
        install_proxy: false,
        remote_configuration: false
    },
    
    lang_use: true,
    white_use: false,
    read_only: false,
    iptv: false,
    feed: true,
    services: true,
    youtube: true,
    geo: true,
    mirrors: true,
    
    push_state: true,
    blur_poster: true,
    hide_important_params: true,
    
    developer: {
        enabled: false
    }
}
</script>

<script src="lampa.js"></script>
```

--------------------------------

### Building Custom Components

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Illustrates how to define and register a custom component class, including its lifecycle methods (`render`, `show`, `hide`, `destroy`) and how to create instances of it.

```javascript
class SearchResultsComponent {
    constructor(object) {
        this.query = object.query
        this.results = object.results || []
        this.html = null
    }
    
    render() {
        this.html = $(
            `<div class="search-results">
                <div class="results-list"></div>
            </div>`
        )
        
        this.results.forEach(item => {
            this.html.find('.results-list').append(
                $(`<div class="result-item">${item.title}</div>`)
            )
        })
        
        return this.html
    }
    
    show(callback) {
        this.html.addClass('visible')
        if (callback) callback()
    }
    
    hide(callback) {
        this.html.removeClass('visible')
        if (callback) callback()
    }
    
    destroy() {
        this.html.remove()
        this.html = null
    }
}

// Register and use
Lampa.Component.add('search_results', SearchResultsComponent)

const search = Lampa.Component.create({
    component: 'search_results',
    query: 'action',
    results: [...] // Assume results is an array of items
})
```

--------------------------------

### Create Various Components

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Use `Lampa.Component.create` to instantiate different screen components. Pass component names and any necessary data. Unregistered components gracefully fall back to the 'nocomponent' instance.

```javascript
// Create main screen
const mainComponent = Lampa.Component.create({
    component: 'main'
})

// Create content detail view
const fullComponent = Lampa.Component.create({
    component: 'full',
    id: 550,
    method: 'movie',
    card: movieData
})

// Create category filter
const categoryComponent = Lampa.Component.create({
    component: 'category',
    title: 'Action Movies',
    genres: '28'
})

// Create TV schedule
const scheduleComponent = Lampa.Component.create({
    component: 'timetable'
})

// Unknown component falls back gracefully
const unknown = Lampa.Component.create({
    component: 'nonexistent'
})
// Returns nocomponent instance instead of error
```

--------------------------------

### Add and Get Favorites

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Adds an item to the user's favorites and retrieves the list of all favorited items. Use for bookmarking.

```javascript
Lampa.Favorite.add(card)
Lampa.Favorite.get()
```

--------------------------------

### Get Default Source Parameter

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Retrieves the default value for the 'source' field from the application's parameters. Used for configuration.

```javascript
const defaultSource = Lampa.Params.field('source')
```

--------------------------------

### Initialize Storage Synchronization

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Set up synchronization for different data types like 'array_string' and 'object_object'. Tasks are executed after storage is ready.

```javascript
Lampa.Storage.sync('online_view', 'array_string')
Lampa.Storage.sync('search_history', 'array_string')
Lampa.Storage.sync('torrents_filter_data', 'object_object')

Lampa.Storage.task(() => {
    console.log('App ready to use storage')
})
```

--------------------------------

### Template Methods

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/INDEX.md

Methods for retrieving and manipulating HTML templates, including getting templates, JavaScript, adding, and string manipulation.

```APIDOC
## Template Methods

### Description
Methods for retrieving and manipulating HTML templates, including getting templates, JavaScript, adding, and string manipulation.

### Methods
- `Template.get`
- `Template.js`
- `Template.add`
- `Template.all`
- `Template.string`
- `Template.prefix`
- `Template.elem`
```

--------------------------------

### Router Methods

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/INDEX.md

Methods for managing application routing, including adding routes, getting route information, and calling routes.

```APIDOC
## Router Methods

### Description
Methods for managing application routing, including adding routes, getting route information, and calling routes.

### Methods
- `Router.add`
- `Router.get`
- `Router.call`
```

--------------------------------

### init

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

Initializes the timer system. This method must be called once during application startup to enable timer functionality and event listeners.

```APIDOC
## init

### Description
Initializes the timer system. Must be called once during application startup.

### Method
`init(): void`

### Returns
`undefined`

### Behavior
- Starts interval checking (every 1000ms)
- Attaches visibility change listener
- Attaches click and keydown event listeners for unpause
- Pauses timers when tab hidden, resumes when tab focused

### Example
```javascript
// In app initialization
Lampa.Timer.init()
```
```

--------------------------------

### elem

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Gets the raw template element without creating a clone. This method returns the actual DOM element as defined in the template.

```APIDOC
## elem

### Description
Gets the raw template element without creating a clone. This method returns the actual DOM element as defined in the template.

### Method
```javascript
elem(name: string): HTMLElement
```

### Parameters
#### Path Parameters
- **name** (string) - Required - Template identifier

### Response
#### Success Response
- Returns the raw template element.

### Request Example
```javascript
const raw = Lampa.Template.elem('card')
```
```

--------------------------------

### Creating UI Components

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Use Lampa.Component.create() to instantiate UI components. Specify the component type and associated data for rendering.

```javascript
const comp = Lampa.Component.create({
    component: 'full',
    id: 550
})
```

--------------------------------

### Use Custom Templates

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Demonstrates retrieving a custom HTML string template ('my_component') and rendering a dynamically generated list template ('dynamic_list') with sample data.

```javascript
// Use custom template
const el = Lampa.Template.get('my_component')
const list = Lampa.Template.js('dynamic_list', {
    items: ['Item 1', 'Item 2', 'Item 3']
})
```

--------------------------------

### Navigate to Full Content View

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Use Lampa.Router.call to navigate to the 'full' screen, displaying detailed information for a content item. Pass the content ID, name, and source.

```javascript
// Show full content view
Lampa.Router.call('full', {
    id: 1399,
    original_name: 'Breaking Bad',
    source: 'tmdb'
})
```

--------------------------------

### Manage User Settings with Storage

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Save and retrieve user preferences like theme and language. Monitor changes to specific settings using a listener.

```javascript
// Save user preferences
Lampa.Storage.set('theme', 'dark')
Lampa.Storage.set('language', 'en')
Lampa.Storage.set('volume', 0.8)

// Retrieve with defaults
const theme = Lampa.Storage.get('theme', 'light')
const language = Lampa.Storage.get('language', 'en')

// Monitor changes
Lampa.Storage.listener.follow('change', (event) => {
    if (event.name === 'theme') {
        console.log('Theme changed to:', event.value)
    }
})
```

--------------------------------

### Show Component with Callback

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Use the `show` method to display a component. An optional callback function can be provided to execute code after the show animation completes.

```javascript
component.show(() => {
    console.log('Component is now visible')
    // Focus on first element, etc.
})
```

--------------------------------

### Component Creation

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Creates and instantiates a component based on configuration. It supports creating built-in components by name or custom components registered via `Lampa.Component.add()`.

```APIDOC
## create

### Description
Creates and instantiates a component based on configuration. It supports creating built-in components by name or custom components registered via `Lampa.Component.add()`.

### Method
```javascript
create(object: {component?: string, ...rest}): ComponentInstance
```

### Parameters
#### Path Parameters
* **object.component** (string) - Optional - Component name/identifier. Defaults to 'nocomponent'.
* **...rest** (object) - Optional - Additional data passed to component constructor.

### Request Example
```javascript
// Create main screen
const mainComponent = Lampa.Component.create({
    component: 'main'
})

// Create content detail view
const fullComponent = Lampa.Component.create({
    component: 'full',
    id: 550,
    method: 'movie',
    card: movieData
})

// Create category filter
const categoryComponent = Lampa.Component.create({
    component: 'category',
    title: 'Action Movies',
    genres: '28'
})

// Create TV schedule
const scheduleComponent = Lampa.Component.create({
    component: 'timetable'
})

// Unknown component falls back gracefully
const unknown = Lampa.Component.create({
    component: 'nonexistent'
})
// Returns nocomponent instance instead of error
```

### Response
Returns a Component instance with methods like `render()`, `show()`, `hide()`, etc. Returns a fallback component instance if the requested component name is not found.
```

--------------------------------

### Get TMDB or CUB Source Class

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/api.md

Returns the appropriate source class based on the provided source identifier. Defaults to 'tmdb' if no source is specified.

```javascript
const tmdbSource = Lampa.Api.source({ source: 'tmdb' })
const cubSource = Lampa.Api.source({ source: 'cub' })

// Default to TMDB
const defaultSource = Lampa.Api.source({})
```

--------------------------------

### Configure Interface Settings

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/configuration.md

Customize interface elements such as language pack loading, store-friendly mode, read-only mode, and poster blurring. Set `white_use` to true to enable store-friendly mode.

```javascript
window.lampa_settings.lang_use = true
window.lampa_settings.white_use = true    // Store-friendly mode
window.lampa_settings.read_only = false
```

--------------------------------

### Get Raw String Value

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Retrieves a value directly from localStorage as a raw string without any type conversion. Useful for accessing non-JSON data.

```javascript
const rawValue = Lampa.Storage.value('token', '')
```

--------------------------------

### Get Stored Value with Default

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Retrieves a value from storage, performing automatic type conversion. Specify a default value to be returned if the key is not found.

```javascript
const theme = Lampa.Storage.get('theme', 'dark')

const settings = Lampa.Storage.get('user_settings', {})

const history = Lampa.Storage.get('search_history', [])

const enabled = Lampa.Storage.get('notifications', false)
```

--------------------------------

### Initialize Timer System

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/timer.md

Call this once during application startup to enable timer functionality and attach necessary event listeners.

```javascript
Lampa.Timer.init()
```

--------------------------------

### use Method

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/emit.md

Adds a component to the emission system, optionally at a specific position. Components can be classes or instances.

```APIDOC
## use

```javascript
use(Module: class | object, position?: number): void
```

Adds a component to the emission system.

### Parameters
#### Path Parameters
- **Module** (class | object) - Required - Component class or instance to register
- **position** (number) - Optional - Index to insert at; null appends to end

### Behavior
- If Module is a function/class, instantiates it with `new Module(this)`
- If already registered, does nothing (prevents duplicates)
- Components can be positioned at specific indices

### Example
```javascript
class AudioComponent {
    constructor(emit) {
        this.emit = emit
    }
    
    onPlay(track) {
        console.log('Playing:', track)
    }
}

class VideoComponent {
    constructor(emit) {
        this.emit = emit
    }
    
    onPlay(track) {
        console.log('Video for:', track)
    }
}

const emit = new Emit()

// Add components
emit.use(AudioComponent)
emit.use(VideoComponent)

// Insert at specific position (index 0 = first)
emit.use(AudioComponent, 0)
```
```

--------------------------------

### Render Component UI

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

After creating a component instance, call its `render()` method to get a jQuery element representing its UI. This element can then be appended to the DOM.

```javascript
const component = Lampa.Component.create({
    component: 'main'
})

const element = component.render()
$('body').append(element)
```

--------------------------------

### Create Custom Component with Lampa Component

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Define a custom component class with render, show, hide, and destroy methods. Register it with Lampa.Component.add and create instances using Lampa.Component.create.

```javascript
class MyComponent {
    constructor(object) {
        this.data = object
        this.html = null
    }
    
    render() {
        this.html = $("<div class=\"my-component\">...</div>")
        return this.html
    }
    
    show(callback) {
        this.html.fadeIn(() => {
            if (callback) callback()
        })
    }
    
    hide(callback) {
        this.html.fadeOut(() => {
            if (callback) callback()
        })
    }
    
    destroy() {
        this.html.remove()
    }
}

// Register
Lampa.Component.add('my_component', MyComponent)

// Use
const comp = Lampa.Component.create({
    component: 'my_component',
    data: 'value'
})
```

--------------------------------

### Make an HTTP Request

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Initiates an HTTP request with a callback for handling the response.

```javascript
Lampa.Network.go({ url: 'https://...' }, callback)
```

--------------------------------

### Get Default Field Value

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Retrieves a default value for a field from the Params settings. This is typically used for setting default values for UI elements or configurations.

```javascript
const defaultSource = Lampa.Storage.field('source')
const defaultLanguage = Lampa.Storage.field('language')
```

--------------------------------

### task

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Loads cache from IndexedDB on application startup. A callback function is invoked when the cache load completes, allowing the app to safely use cached values afterward.

```APIDOC
## task

### Description
Loads cache from IndexedDB on application startup. A callback function is invoked when the cache load completes, allowing the app to safely use cached values afterward.

### Method
```javascript
task(callback: function): void
```

### Parameters
#### Path Parameters
* **callback** (function) - Required - Invoked when cache load completes

### Returns
`undefined`

### Request Example
```javascript
Lampa.Storage.task(() => {
    console.log('Storage cache loaded')
    // App can now safely use cached values
})
```
```

--------------------------------

### Get Grammatical Form of a Number

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/utils.md

Selects the correct grammatical form of a word based on a number, primarily for Russian/Slavic languages. Requires an array of singular, few, and many forms.

```javascript
const forms = ['файл', 'файла', 'файлов']
Lampa.Utils.declOfNum(1, forms)           // "файл"
Lampa.Utils.declOfNum(2, forms)           // "файла"
Lampa.Utils.declOfNum(5, forms)           // "файлов"
Lampa.Utils.declOfNum(21, forms)          // "файл"
```

--------------------------------

### Create Router Instance

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/router.md

Instantiates a new Router object. This creates a router with an empty set of routes.

```javascript
const router = new Router()
```

--------------------------------

### Extract Values from Grouped Data

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/arrays.md

Demonstrates extracting specific values, such as IDs or titles, from an array of objects. This example shows using `groupBy` and `getValues` for data transformation.

```javascript
// Extract IDs from objects
const movies = [
    { id: 1, title: 'Movie 1' },
    { id: 2, title: 'Movie 2' }
]

const ids = movies.map(m => m.id)
// or extract all titles:
const titles = Lampa.Arrays.getValues(
    Lampa.Arrays.groupBy(movies, 'genre')
)
```

--------------------------------

### Component Event Broadcasting

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Instantiate Emit for multi-component event systems. Use .use() to register components and .emit() to broadcast events.

```javascript
const emit = new Lampa.Emit()
emit.use(ComponentClass)
emit.emit('event', data)
```

--------------------------------

### Get Detailed Content Information

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Use Lampa.Api.full to fetch detailed information about a specific content item. Specify the ID, method ('tv' or 'movie'), and source (e.g., 'tmdb').

```javascript
// Get detailed content information
Lampa.Api.full(
    { id: 1399, method: 'tv', source: 'tmdb' },
    (data) => {
        console.log('Title:', data.name)
        console.log('Rating:', data.vote_average)
    }
)
```

--------------------------------

### Load Cache from IndexedDB on Startup

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Loads cache from IndexedDB on application startup. The callback is invoked when the cache load completes, indicating the app can safely use cached values.

```javascript
Lampa.Storage.task(() => {
    console.log('Storage cache loaded')
    // App can now safely use cached values
})
```

--------------------------------

### Get Raw HTML String of Template

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Retrieves the raw HTML string of a registered template without rendering. Useful for inspecting the template's structure or checking its existence.

```javascript
const html = Lampa.Template.string('card')
console.log(html)  // Raw HTML

// Useful for inspection
if (!Lampa.Template.string('custom')) {
    console.log('Custom template not found')
}
```

--------------------------------

### Register and Use Custom Component

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Define a custom component class and register it using `Lampa.Component.add`. This allows creating instances of your custom component with `Lampa.Component.create`.

```javascript
// Define custom component
class MyCustomComponent {
    constructor(object) {
        this.data = object
    }
    
    render() {
        return $(\'<div class="custom">My Component</div>\')
    }
    
    show(callBack) {
        if (callBack) callBack()
    }
    
    hide(callBack) {
        if (callBack) callBack()
    }
    
    destroy() {
        // Cleanup
    }
}

// Register it
Lampa.Component.add('my_custom', MyCustomComponent)

// Use it
const comp = Lampa.Component.create({
    component: 'my_custom',
    custom_data: 'value'
})
```

--------------------------------

### Initialize Live Clock Widget

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/utils.md

Use Lampa.Utils.time to initialize a live clock widget. The clock updates automatically and can be destroyed on page unload.

```javascript
const clockWidget = document.querySelector('.header-clock')
const clock = Lampa.Utils.time(clockWidget)

// Clock updates automatically every 60 seconds

// On page unload
function cleanup() {
    clock.destroy()
}
```

--------------------------------

### main

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/api.md

Fetches main page data, typically featured or recommended content.

```APIDOC
## main

### Description
Fetches main page data.

### Method Signature
`main(params?: object, onComplete?: function, onError?: function): void`

### Parameters
#### Params Object
- **params.source** (string) - Optional - Content source (e.g., 'tmdb').

#### Callbacks
- **onComplete** (function) - Optional - Callback with main page data.
- **onError** (function) - Optional - Error callback.

### Request Example
```javascript
// Fetch main page data
Lampa.Api.main(
    { source: Lampa.Storage.get('source', 'tmdb') },
    (mainData) => {
        console.log('Featured content:', mainData)
    },
    (error) => {
        console.error('Failed to load:', error)
    }
)
```
```

--------------------------------

### Get Raw Template Element

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Retrieves the raw, un-cloned HTMLElement for a registered template. Use this when you need direct access to the template's DOM structure without creating a copy.

```javascript
const raw = Lampa.Template.elem('card')
```

--------------------------------

### Build Custom Modal UI

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/template.md

Retrieve a modal template using Lampa.Template.get(), then manipulate its elements to set content and add buttons. Finally, append the modal to the body.

```javascript
// Get template
let modal = Lampa.Template.get('modal')

// Find and fill elements
modal.find('.modal-title').text('Confirm Action')
modal.find('.modal-body').html('<p>Are you sure?</p>')
modal.find('.modal-footer').append(
    $('<button>Cancel</button>'),
    $('<button>Confirm</button>')
)

// Add to page
$('body').append(modal)
```

--------------------------------

### Keyboard Input Handling

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/exported-modules.md

Control keyboard input with Lampa.Keypad. Use .enable() and .disable() to manage input state, and .listener.follow() to subscribe to keydown events.

```javascript
Lampa.Keypad.enable()
Lampa.Keypad.disable()
Lampa.Keypad.listener.follow('keydown', handler)
```

--------------------------------

### Get Month Names

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/utils.md

Returns an array of month names. Optionally, can return month names in genitive form by passing `true` as an argument. Useful for displaying month names in various contexts.

```javascript
const months = Lampa.Utils.getMoths()
// ["January", "February", "March", ..., "December"]

const monthsGenitiv = Lampa.Utils.getMoths(true)
// ["of January", "of February", ..., "of December"]
```

--------------------------------

### listener

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/storage.md

Provides a Subscribe instance to listen for storage change events like 'change', 'add', and 'clear'.

```APIDOC
## listener

### Description
Global Subscribe instance that emits storage change events.

### Type
Subscribe instance

### Events
- `change` — Fires when a value is set (unless nolisten flag is true)
- `add` — Fires when a value is added to an array
- `clear` — Fires when storage is cleared
```

--------------------------------

### Shuffle Array From Specific Index

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/arrays.md

Shuffles array elements starting from a given index. Useful for partial shuffling without affecting the beginning of the array. Returns undefined as it modifies the array in-place.

```javascript
const list = ['a', 'b', 'c', 'd', 'e']
Lampa.Arrays.shuffleArrayFromIndex(list, 2)
// list = ['a', 'b', 'e', 'd', 'c'] (only from index 2 shuffled)
```

--------------------------------

### Load Initial Content

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/api.md

Fetches main page data, typically used for displaying featured content on application load. It uses the user's preferred source from storage.

```javascript
// Fetch main page data
Lampa.Api.main(
    { source: Lampa.Storage.get('source', 'tmdb') },
    (mainData) => {
        console.log('Featured content:', mainData)
    },
    (error) => {
        console.error('Failed to load:', error)
    }
)
```

--------------------------------

### Add Components with Emit.use()

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/emit.md

Registers components with the Emit system. Components can be added as classes or instances, and their insertion position can be specified.

```javascript
class AudioComponent {
    constructor(emit) {
        this.emit = emit
    }
    
    onPlay(track) {
        console.log('Playing:', track)
    }
}

class VideoComponent {
    constructor(emit) {
        this.emit = emit
    }
    
    onPlay(track) {
        console.log('Video for:', track)
    }
}

const emit = new Emit()

// Add components
emit.use(AudioComponent)
emit.use(VideoComponent)

// Insert at specific position (index 0 = first)
emit.use(AudioComponent, 0)
```

--------------------------------

### Dynamic Component Addition and Removal

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/emit.md

Demonstrates adding and removing components from the Emit system dynamically at runtime. Handlers for removed components will no longer be invoked.

```javascript
const emit = new Emit()

const audio = new AudioComponent()
emit.use(audio)

emit.emit('play', track)  // Works

emit.unuse(audio)
emit.emit('play', track)  // Audio handler not called

emit.use(audio)
emit.emit('play', track)  // Works again
```

--------------------------------

### Navigate to Category Screen

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/README.md

Use Lampa.Router.call to navigate to the 'category' screen. Specify a title and relevant genres for filtering content.

```javascript
// Show category with filters
Lampa.Router.call('category', {
    title: 'Action Movies',
    genres: '28'
})
```

--------------------------------

### show

Source: https://github.com/yumata/lampa-source/blob/main/_autodocs/component.md

Displays the component and optionally calls a callback function when the show animation completes.

```APIDOC
## show

### Description
Displays the component and optionally calls a callback when animation completes.

### Method
show

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### callback
- **callback** (function) - Optional - Called when show animation finishes

### Request Example
```javascript
component.show(() => {
    console.log('Component is now visible')
    // Focus on first element, etc.
})
```

### Response
#### Success Response (undefined)
Returns `undefined`.

#### Response Example
```javascript
// No explicit return value
```
```
Tokens:
Raw