All options are optional. You may use multiple Weavy.presets together with options when constructing a weavy instance. Multiple option sets are merged together.

If you want to connect to a specific server use the url option.

These option presets are available for easy configuration

• Weavy.presets.noplugins - Disable all plugins
• Weavy.presets.core - Use the minimal core plugin configuration without additional plugins.

var weavy = new Weavy();

var devSettings = {
    logging: true
};

var coreDevWeavy = new Weavy(Weavy.presets.core, devSettings, { url: "http://myweavysite.dev" });

Main options for Weavy. The JWT option is required. When weavy initializes, it connects to the server and processes the options as well as using them internally.

The weavy instance id

The url of the weavy server.

True when inatialization has started

True when frames are blocked by Content Policy or the browser

True when weavy is loading options from the server.

True when weavy has loaded options from the server.

Reference to the instance of the realtime connection to the server.

Appends the weavy-id to an id. This makes the id unique per weavy instance. You may define a specific weavy-id for the instance in the options. If no id is provided it only returns the weavy id. The weavy id will not be appended more than once.

Removes the weavy id from an id created with getId

Initializes weavy. This is done automatically unless you specify init: false in options.

Creates an isolated shadow root in the DOM tree to place nodes in.

Get a Weavy shadow root by id.

Method for calling JSON API endpoints on the server. You may send data along with the request or retrieve data from the server.

Fetch API is used internally and you may override or extend any settings in the external:fetch by providing custom fetch init settings.

You may of course call the endpoints using any other preferred AJAX method, but this method is preconfigured with proper encoding and crossdomain settings.

// Create a space and open it as a panel
weavy.ajax("/api/spaces/", { name: "My Space" }, "POST").then(function(result) {
  weavy.panels.addPanel("space" + result.id, result.url);
  weavy.panels.open("space" + result.id);
});

// Search for a space
weavy.ajax("/api/search", { q: "My Space", et: "space"}).then(function(result) {
  console.log("Found " + result.count + " results");
});

Destroys the instance of Weavy. You should also remove any references to weavy after you have destroyed it. The destroy event will be triggered before anything else is removed so that plugins etc may unregister and clean up, before the instance is gone.

Client configuration data from the server. Based on what is passed in options to the server and currently defined spaces.

Data about the current user. Use weavy.user.id to get the id of the user.

Reference to the instance of the WeavyAuthentication for the current server.

You always need to define a JWT provider in your options. This may be a function that returns a JWT string or returns a promise that resolves a JWT string. The function will be called again whenever a new JWT token is needed. You may also provide a JWT string directly, then you can't benifit from weavy requesting a new token when needed.

See Client Authentication for full authentication documentation.

Triggered when the authentication process has started.

Triggered when user data needs to be cleared. For example when a user is signing out.

Triggered when the authentication process was unsuccessful.

Instance of WeavyEvents which enables propagation and before and after phases for events.

The event system provides event chaining with a bubbling mechanism that propagates all the way from the emitting child trigger to the weavy instance.

All events in the client have three phases; before, on and after. Each event phase is a prefix to the event name.

• The before:event-name is triggered in an early stage of the event cycle and is a good point to modify event data or cancel the event.
• The on:event-name is the normal trigger point for the event. It does not need to be prefixed when registering an event listener, you can simly use the event-name when you register a listener. This is the phase you normally use to register event listeners.
• The after:event-name is triggered when everything is processed. This is a good point to execute code that is dependent on that all other listers have been executed.

Cancelling an event by calling event.stopPropagation() will stop any propagation and cause all the following phases for the event to be cancelled.

Event that is triggered when the weavy instance is initiated. This is done automatically unless you specify init: false in options. You may use the before:init event together with event.stopPropagation() if you want to intercept the initialization.

Triggered when init data has been loaded from the server.

Triggered when a shadow root is created

Triggered when the frame check is done.

Event triggered when the Weavy instance is about to be destroyed. Use this event for clean up.

• Any events registered using Weavy#on and Weavy#one will be unregistered automatically.
• Timers using whenTimeout will be cleared automatically.
• All elements under the Weavy#nodes#root will be removed.

Triggers when the number of unread conversations or notifications change.

weavy.on("badge", function (e, data) {
    weavy.log("New notifications count", data.notifications);
    weavy.log("Unread conversations count", data.conversations);
});

Event triggered when weavy is building up the DOM elements.

Use this event to build all your elements and attach them to weavy. At this point you may safely assume that weavy.nodes.container is built.

Good practice is to build all elements in the build event and store them as properties on weavy. Then you can attach them to other Elements in the after:build event. This ensures that all Elements are built before they are attached to each other.

If you have dependencies to Elements built by plugins you should also check that they actually exist before attaching to them.

Often it's a good idea to check if the user is signed-in using WeavyAuthentication#isAuthenticated unless you're building something that doesn't require a signed in user.

weavy.on("build", function(e, root) {
    if (weavy.authentication.isAuthorized()) {
        weavy.nodes.myElement = document.createElement("DIV");
    }
});

weavy.on("after:build", function(e, root) {
    if (weavy.authentication.isAuthorized()) {
        if (weavy.nodes.overlay) {
            weavy.nodes.overlay.appendChild(weavy.nodes.myElement);
        }
    }
})

Event triggered when weavy has initialized, connected to the server and recieved and processed options, and built all components. Use this event to do stuff when everything is loaded.

Often it's a good idea to check if the user is signed-in using Weavy#isAuthenticated unless you're building something that doesn't require a signed in user.

weavy.on("load", function() {
    if (weavy.authentication.isAuthorized()) {
        weavy.alert("Client successfully loaded");
    }
});

Class for wrapping native console logging.

• Options for turning on/off logging
• Optional prefix by id with color

Instance of the panel manager for all iframes in the weavy instance.

Placeholder for all DOM node references. Put any created elements or DOM related objects here.

All enabled plugins are available in the plugin list. Anything exposed by the plugin is accessible here. You may use this to check if a plugin is enabled and active.

Set plugin options and enable/disable plugins using options.

if (weavy.plugins.alert) {
  weavy.plugins.alert.alert("Alert plugin is enabled");
}

Creates a managed timeout promise. Use this instead of window.setTimeout to get a timeout that is automatically managed and unregistered on destroy.

var mytimeout = weavy.whenTimeout(200).then(function() { ... });
mytimeout.cancel(); // Cancel the timeout

Promise that the blocking check has finished. Resolves when frame-check is triggered.

weavy.whenReady().then(function() { ... })

Promise that resolves when the initialization has been started

Promise that weavy has recieved the after:load event

weavy.whenLoaded().then(function() { ... })

List of all current defined spaces as an Array.

Selects, fetches or creates a space in the weavy instance.

The space needs to be defined using a space definition object containing at least a key, which will fetch or create the space on the server. If the defined space already has been set up, the space will only be selected in the client. After the space is defined it can be quickly selected in the client using only the id (int) or the key (string) of the space, which never will create nor fetch the space from the server.

// Define a space that will be fetched or created on the server
var space = weavy.space({ key: "mykey", name: "My Space" });

// Select the newly defined space
var spaceAgain = weavy.space("mykey");

The hardcoded semver version of the weavy-script.

Option preset configurations. Use these for simple configurations of common options. You may add your own presets also. The presets may be merged with custom options when you create a new Weavy, since the contructor accepts multiple option sets.

// Load the minimal weavy core without any additional plugins.
var weavy = new Weavy(Weavy.presets.core, { url: "https://myweavysite.com" });

Default options. These options are general for all Weavy instances and may be overridden in options. You may add any general options you like here. The url is always set to the installation where your weavy.js was generated.

// Defaults
Weavy.defaults = {
    container: null,
    className: "",
    https: "adaptive",
    init: true,
    includePlugins: true,
    preload: true,
    url: "/"
};

// Set a general url to connect all weavy instances to
Weavy.defaults.url = "https://myweavysite.com";
var weavy = new Weavy();

Placeholder for registering plugins. Plugins must be registered and available here to be accessible and initialized in the Weavy instance. Register any plugins after you have loaded weavy.js and before you create a new Weavy instance.

Id list of all created instances.

Weavy shadow root to enable closed scopes in the DOM that also can be managed and removed. The shadow root will isolate styles and nodes within the root.

Structure:

{parent} ➜ <weavy/> ➜ {ShadowDOM} ➜ {container}