Develop your modules

Learn more about developing new modules in Parallelix and how they work in a common bundle

How it Works?

Parallelix uses a modular system in order to provide a single API for different platforms. In essence, each module is a wrapper over the official API or SDK.

1. The Parallelix client connects modules specified in the configuration by loading additional JS scripts;

2. After initializing the libraries, it sorts them by priority and calls the IsCurrentPlatform() module on each one

3. After the required platform is found - its initialization method is called and the client becomes ready to work, providing the required methods with a unified interface

If no platform has been connected, or the application was launched on an unknown platform, the default web module will be connected. Therefore, it is important that it is located in the folder with your modules and is available for connection.

Now let's take a look at the structure of the module.

---

Module Structure

All modules are stored in the directory of your site, which is specified in the Parallelix configuration. From there they will be connected by name.

It is important to respect the naming of your module:

parallelix.YOUR_MODULE_NAME.js

for example:
parallelix.vk.js

All modules are inherited from the base virtual class ParallelixWrapper. Thus, the methods supported by a module can be described, while the rest will cause an exception.

Let's understand the class structure of your new module:

// Your Parallelix module extends basic virtual ParallelixWrapper
class ParallelixMyModule extends ParallelixWrapper {
    // This constructor used at module initialization from Parallelix main class
    // instance = Parallelix main class instance
    // options  = Platform-specific options object from Parallelix config
    constructor(instance, options = {}) {
        const defaultOptions = {
            // Your Default Options
        };
        
        // Extend Default options by constructor options
        let extendedOptions = {...defaultOptions, ...options};
        super(instance, extendedOptions);
        this.options = extendedOptions;
        
        // Add Platform Instance (Required!)
        this.platform = instance;
        
        // Initialization Flag
        this.isInitialized = false;
        
        // API or SDK Client Instance (for Example vkBridge object)
        this.invoker = null;
        
        // Add Event Handlers
        this.OnError = (options?.OnError && typeof options?.OnError === "function") ? options.OnError : (error) => {
            console.error(`Parallelix Web Wrapper Error: ${error.message}`);
        };
        this.OnInitialized = (options?.OnInitialized && typeof options?.OnInitialized === "function") ? options.OnInitialized : (data) => {
            console.log(`Parallelix Web Wrapper Initialized`);
        };
    }
    
    /**
     * Get Module Priority for Platform Detection
     * @returns {number} from 0 to 999
     */
    get Priority(){
        return 1;
    }
    
    /**
     * Check if this module is for current platform
     * @returns {boolean}
     */
    IsCurrentPlatform(){
        // Here you can determine platform
        return true;
    }
    
    /**
     * Initialize Your Platform SDK
     */
    Initialize(){
        self.invoker = self;            // Put here Your Platform-specific SDK
        self.isInitialized = true;      // Initialization Flag
        self.OnInitialized({});         // Call Initialization Ends Handler
        self.HandleEvents();            // Handle All events from platform-specific SDK
    }
    
    /**
     * Handle All Web Events
     */
    HandleEvents(){
        let self = this;

        // Check if your module is initialized
        if(!self.isInitialized) {
            onError(new Error("My Module is not initialized"));
            return;
        }   

        // Subscribe to Web App Events
        window.addEventListener("message", (event) => {
            if(!event.data) return;

            const { type, data } = event.data;
            self.GetEventListener(type)?.(data);
        });
    }
    
    // *****
    // Other Methods Implementation
    // *****
}

// It is important to use the same identifier for the object as in the module file name.
Parallelix._platformClasses["YOUR_MODULE_NAME"] = ParallelixMyModule;

Next, you can create method implementations that will be used for your module on your platform. For this you can refer to the documentation of common classes.

---

Platform Detection

When discovering a platform, your module must check for certain attributes that a Web application can use to realize that it should currently be using your module.

Also, don't forget to prioritize your module check via the Priority() field. The minimum priority is 0, the maximum is 999.

---

Publish your Modules

Your help is always welcome. Submit your new modules directly to us on GitHub. We will be sure to add it to new releases.