Finsemble: CHANGELOG

Change Log


1.2.0 - 2017-07-25

  • Bug fixes.
  • Added a way to quit a finsemble application: simply call FSBL.shutdownApplication().
  • New onShutdown event. This event allows for components to register cleanup actions to be completed on application quit. For more, see the finsemble library lifecycle.
  • New onReady event for any client that uses the baseClient. You now can add FSBL.Clients.WindowClient.addEventListener('onReady', cb). This is unlikely to be used unless you're creating a custom component. Note: We still have FSBL.addEventListener('onReady', cb).
  • Configuration Enhancements

    • Openfin manifest now modifiable in the seed project at configs/openfin/manifest-local.json
      • Config variables (e.g. $applicationRoot) supported in JSON config files for added flexibility
      • See updated Config Tutorial for more information.

    Special Note: If you customize your seed-project's environment, please review the configuration notes at the bottom of the tutorial Getting Finsemble

  • Finsemble-CLI has a new command: finsemble-cli kill. This will kill node processes that our build process spins up, as well as any lingering openfin processes.
  • Mind control improvements:
    • Can now specify an array of files to include in your components. Documentation
  • Toolbar and App Launcher enhancements - Documentation
    • Toolbar config now has a menuItems property to customize the items on the Toolbar
    • App launcher can now filter elements shown dynamically

1.1.0 - 2017-07-05

Changed

  • Bugfixes and performance improvements.

Added

  • Documentation updates
  • Alpha version of assimilation.
  • LauncherClient improvements (e.g., better handling of monitor-connections/disconnections).
  • Allow all system components to be turned off (e.g., menus, dialogs, etc).

Enabling Assimilation

To turn on assimilation, you will need to modify two files.

  1. First, you need to make sure that the The betaFeatures.assimilation property in configs/application/config.json matches the config below:

    "assimilation": {
     "enabled": false,
     "appAssets": [
         {
             "src": "/hosted/assimilation.zip",
             "version": "1.0.2",
             "alias": "assimilation",
             "target": "CppWindowsHook.exe"
         },
         {
             "src": "/hosted/putty.zip",
             "version": "1.0.0",
             "alias": "putty",
             "target": "putty.exe"
         }
     ]
    }

    The appAssets property is an array of external assets that are bundled and delivered with your application. The first application in the array above is our application that brings native windows programs into finsemble's snapping and docking; it also allows you to bundle your own applications and have them participate in the workspace. The second application is simply an example. To open it, launch NativeTest from the "Apps" menu on the toolbar.

  2. Make sure that finsemble-seed/server/FinsembleConfigs.js matches what's on github, https://github.com/ChartIQ/finsemble-seed/blob/master/server/FinsembleConfigs.js.

The major changes here are bandaids. Soon we will allow you unfettered access to the openfin manifest. Since it is currently unavailable in the seed project, the code we've added will prepend your application's baseURL to your external assets. If you want to host assets on another server, simply put the full path in the src property of your external asset. We assume that any external application without http in its src is hosted alongside the rest of the application files (e.g., http://localhost:3375/yourSubDirectory/hosted/externalAsset.zip).

  1. To add your application to the app launcher, make sure the config below is in your components.json file. Replace the alias property, the key, and the id with information related to your native application.
    "NativeTest": {
     "window": {
         "id": "NativeTest",
         "native":true,
         "alias": "putty",
         "path":"",
         "url":"",
         "defaultHeight": 600,
         "autoShow": true,
         "alwaysOnTop": false,
         "resizable": true,
         "showTaskbarIcon": false,
         "contextMenu": true,
         "addToWorkspace": true
     },
     "component": {
     },
     "foreign": {
         "services": {
             "workspaceService": {
                 "isArrangable": true
             }
         },
         "components": {
             "App Launcher": {
                 "launchableByUser": true
             },
             "Window Manager": {
                 "persistWindowState": false,
                 "FSBLHeader": true
             }
         }
     }
    }
    If you get stuck trying to add your own application, send us a note at support@finsemble.com or send us a message on slack.

1.0.0 - 2017-06-30

This is the first official release of Finsemble.

New Features

  • Snapping windows: Windows now snap to monitor edges and to each other, making it quick and easy for users to assemble their ideal workspace. Snapping is automatically enabled (supported by a new service "dockingService").

  • Mind Control: Allows JavaScript to be injected at run-time into select components. You can use this JavaScript to modify the behavior of the component by interacting with the FSBL API. See the Mind Control tutorial for more information.

API Changes

  • Support for storage adapters now allow developers to save data to locations other than localStorage. Also, the Storage Client is enhanced. See the Storing Data tutorial for more information.

  • LauncherClient has been significantly revised to make component launch more flexible. The new model uses a paradigm based off of CSS div positioning, with the capability of targeting specific monitors or launching components in positions relative to other components. A new "windowIdentifier" paradigm allows windows to be referenced more flexibly. Components can now be set to spawnOnStart and spawnOnAllMonitors. They can also generically make claims on monitor space - to support building custom toolbars. See LauncherClient#spawn and LauncherClient#showWindow API calls.

    These are breaking changes from the Beta release - any calls to spawn() should be rewritten to use the new parameters.

  • The RouterClient now dynamically selects an underlying transport. For cross-domain components (i.e. components not on the same domain as the Router Service) an OpenFin-Bus transport is selected. For same-origin components a faster ShareWorker transport layer is selected. With these enhancements, RouterClient initialization is no longer synchronous, requiring a call to RouterClient.onReady() before using other Router method; however, this is transparent to components that only access the RouterClient though the FSBL object (i.e. the RouterClient is preinitialized in FSBL).

    These are potentially breaking changes from the Beta release - application should either use the RouterClient in FSBL (or for services inheriting from the baseService, reference the preinitialized this.RouterClient) or call RouterClient.onReady() before invoking other router methods.

  • WindowClient now offers fitToDOM() method that allows a window's height to automatically be resized to fit its DOM contents. This is useful for elements such as menus that have variable height.

  • A new ConfigClient provides run-time access to Finsemble configuration. See the Understanding Configuration tutorial for more information. If you participated in the Beta and wish to retain you project, then your config files will need to be modified to the new format. See "Upgrade Steps" below.

  • The Finsemble Toolbar is no longer required. If you would like to disable, simply remove the ToolBar entry under components in configs/application/config.json.

New Beta Features

  • Window grouping: Snapped windows "fuse" to form window groups. A window group can then be moved by the end user, for instance from one monitor to another monitor. Window grouping is undergoing user testing and is released as a beta for feedback. To enable window grouping set the docking.enabled flag in the configs/application/config.json file. We're currently working out the kinks in this feature, it should be enabled by default in the coming weeks.

  • Assimilation: Allows Finsemble to launch native applications from the toolbar which participate in snapping and workspaces. See the Assimilation tutorial for more information.

Other Improvements

  • Adaptable Blotter from http://www.adaptabletools.com/ is now available as a Finsemble component!
  • Auto Arrange can now be reversed with a second click.
  • The build process (npm run dev) has been improved to increase speed.
  • Application startup time has been improved.
  • Support for OpenFin version 7.x
  • Finsemble is now loaded via OpenFin's "preload" capability. This means that it is reliably available on any component, even cross domain!

Upgrade Steps

  1. Copy your custom services/componenets/clients that you've built during the beta period into another folder.
  2. Update your seed project. We've made many enhancements to the build process and configuration files - too many to give you a clean step-by-step upgrade process. A fresh clone from github should be all you need to do.
  3. Delete from under your user directory AppData\Local\OpenFin\cache.
  4. Copy your files from your temporary folder back into their respective folders inside of ./src/.
  5. Make sure that your terminal is logged in to NPM.
  6. run npm install.
  7. run npm update -g @chartiq/finsemble-cli;
  8. run npm run dev.

If you have problems, contact us.



0.4.1 - 2017-05-19

  • Added placeholder and hooks for authentication. See the Enabling Authentication Tutorial for instructions on building your own authentication component. The tutorial also includes information on disabling authentication.
  • The authentication placeholder (i.e. the included sample code) prompts for username and password on startup. All storage is now keyed off the username, so the configuration of the application is determined by the entered username (new usernames automatically become new users). The password field is ignored in the placeholder....any password works.

0.4 - 2017-05-02


0.3.1 - 2017-04-21

Minor bug fixes

Fixes

  • Direct chat component to the correct url.
  • Fix some icons issues in the toolbar and windows taskbar.

0.3.0 - 2017-04-19

You may be wondering, "Where is 0.2?" The short answer is that Brad messed up bumping the npm version. So 0.3.0 is what we're working with. Hope you enjoy the new features!

Added

  • User defined components - Through the App Launcher, a user can now add their own components (Your own web pages,Google,CNN,etc) and see them in the App Launcher.Currently, these do not persist in workspaces.
  • Allow developers to set UUID, Port, and host for local, dev, staging, and prod environments.
  • Added way for users to add storage adaptors.
  • Added support for hosting finsemble apps on relative paths.
  • Cleaned up top-level api responses (you should parse response instead of response.data inside of API Calls. If responding to a router request, still parse response.data).
  • Workspaces can be pinned.
  • New look and feel for the toolbar, window header, and dialogs.
  • bug fixes.

Changed

  • Documentation fixes.

Migration steps

We're aware that making changes to your project's structure is a huge pain - we certainly don't intend on making this process commonplace. For this release, however, there are several changes to the underlying application bootstrapping/build process.

There are two paths to migration:

  1. Copying the components that you've already created into a fresh copy of the seed project, or
  2. Modifying your project to match the new configuration.

Copying Components

  1. Clone the seed project into a different folder.
  2. Run npm install.
  3. run npm update -g @chartiq/finsemble-cli
  4. Use the CLI to create your components.
  5. Copy src/components from your old seed into the root of your new project.

Try to run npm run dev. Contact us if this doesn't work and we'll jump on a call to figure out what isn't set up properly.

Modifying your existing project.

  1. Replace src/node_fileserver/FinsembleConfigs.js with the file in the seed project on the master branch.
  2. create configs/startup.json; copy contents from the master branch of the seed project and put in the desired port/hostname configuration.
  3. Modify gulpfile.js

    • On line 9 paste var StartupConfig = require("./configs/startup");. Make sure to update any locations using a port number to the use startup config.
    • Replace line 143 (configPath inside of the launchOpenfin command) with configPath: StartupConfig[env].serverConfig.
    • In the gulp task devServer change launchOpenfin() to launchOpenfin("dev") Also, change all launchOpenfin function calls to the correct environment. The will match up to your startup config.
  4. run npm install.

  5. run npm update -g @chartiq/finsemble-cli;
  6. run npm update @chartiq/finsemble;
  7. run npm run dev. If it doesn't work, contact us and we'll jump on a call with you.

We apologize for the extensive changes. It's unlikely that we'll do this to you again.

The Finsemble Dev Team.

Misc Integration notes:

  1. If you have components from a previous release, that you based on our tutorial on building an application, make sure to remove this rule from your CSS.
* {
    display: block;
}

If you don't, you'll get some lovely CSS plastered on the background of your component's DOM.

  1. If you're playing with accountList/accountDetail from the tutorial, make sure your call to LauncherClient.getActiveDescriptors parses response instead of response.data.