Nimoy Prospers Mystically

    jbl-ui-components

    0.1.0 • Public • Published

    Welcome to RIO-UI

    Rio-ui is the frontend component of the Rio project. It's a React/Apollo project designed to be as lightweight and low-maintenance as possible. It uses create-react-app to manage the majority of its dependencies, imports the majority of its UI components from our rio-ui-components library, and some business logic from our rio-ui-logic library.

    Tools we use

    Rio-ui uses create-react-app to manage the majority of its dependencies, so updating versions should be a little less of a headache. We use a number of tools on top of CRA for various purposes, these modules and the reasoning behind using them is as follows:

    Accounting Great tool for managing currency formatting

    Classnames Tool for cleanly toggling css classes

    Husky Our tool of choice for git commit hooks

    Lint-staged A useful tool for linting any staged changes before commit/push

    Lodash A useful library of tools for various minor jobs

    Moment Similar to accounting but for managing times

    Node-sass-chokidar Our SASS compiler of choice, chokidar watcher is much more efficient than the default node-sass watcher

    Npm-run-all Tool for concurrently running multiple NPM tasks (like watch-css + start-js)

    Prettier Used for formatting js/css etc. to ensure consistency

    React-router-dom Browser version of react-router, for client-side routing

    React-apollo React components/bindings for working with apollo

    Graphql Required graphql parser for apollo-client

    Apollo-boost Bundle of common Apollo tools, contains apollo-client, apollo-cache-inmemory, apollo-link-http, apollo-link-state, apollo-link-error, apollo-link-state, graphql-tag

    Create React App readme

    Below you will find some information on how to perform common tasks with CRA. Full CRA docs are available on GitHub.

    Table of Contents

    Updating to New Releases

    Create React App is divided into two packages:

    • create-react-app is a global command-line utility that you use to create new projects.
    • react-scripts is a development dependency in the generated projects (including this one).

    You almost never need to update create-react-app itself: it delegates all the setup to react-scripts.

    When you run create-react-app, it always creates the project with the latest version of react-scripts so you’ll get all the new features and improvements in newly created apps automatically.

    To update an existing project to a new version of react-scripts, open the changelog, find the version you’re currently on (check package.json in this folder if you’re not sure), and apply the migration instructions for the newer versions.

    In most cases bumping the react-scripts version in package.json and running npm install in this folder should be enough, but it’s good to consult the changelog for potential breaking changes.

    We commit to keeping the breaking changes minimal so you can upgrade react-scripts painlessly.

    Folder Structure

    After creation, your project should look like this:

    my-app/
      README.md
      node_modules/
      package.json
      public/
        index.html
        favicon.ico
      src/
        App.css
        App.js
        App.test.js
        index.css
        index.js
        logo.svg
    

    For the project to build, these files must exist with exact filenames:

    • public/index.html is the page template;
    • src/index.js is the JavaScript entry point.

    You can delete or rename the other files.

    You may create subdirectories inside src. For faster rebuilds, only files inside src are processed by Webpack.
    You need to put any JS and CSS files inside src, otherwise Webpack won’t see them.

    Only files inside public can be used from public/index.html.
    Read instructions below for using assets from JavaScript and HTML.

    You can, however, create more top-level directories.
    They will not be included in the production build so you can use them for things like documentation.

    Available Scripts

    In the project directory, you can run:

    npm start

    Runs the app in the development mode.
    Open http://localhost:3000 to view it in the browser.

    The page will reload if you make edits.
    You will also see any lint errors in the console.

    npm test

    Launches the test runner in the interactive watch mode.
    See the section about running tests for more information.

    npm run build

    Builds the app for production to the build folder.
    It correctly bundles React in production mode and optimizes the build for the best performance.

    The build is minified and the filenames include the hashes.
    Your app is ready to be deployed!

    See the section about deployment for more information.

    npm run eject

    Note: this is a one-way operation. Once you eject, you can’t go back!

    If you aren’t satisfied with the build tool and configuration choices, you can eject at any time. This command will remove the single build dependency from your project.

    Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except eject will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.

    You don’t have to ever use eject. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.

    Installing a Dependency

    The generated project includes React and ReactDOM as dependencies. It also includes a set of scripts used by Create React App as a development dependency. You may install other dependencies (for example, React Router) with npm:

    npm install --save react-router

    Alternatively you may use yarn:

    yarn add react-router

    This works for any library, not just react-router.

    Running Tests

    Note: this feature is available with react-scripts@0.3.0 and higher.
    Read the migration guide to learn how to enable it in older projects!

    Create React App uses Jest as its test runner. To prepare for this integration, we did a major revamp of Jest so if you heard bad things about it years ago, give it another try.

    Jest is a Node-based runner. This means that the tests always run in a Node environment and not in a real browser. This lets us enable fast iteration speed and prevent flakiness.

    While Jest provides browser globals such as window thanks to jsdom, they are only approximations of the real browser behavior. Jest is intended to be used for unit tests of your logic and your components rather than the DOM quirks.

    We recommend that you use a separate tool for browser end-to-end tests if you need them. They are beyond the scope of Create React App.

    Filename Conventions

    Jest will look for test files with any of the following popular naming conventions:

    • Files with .js suffix in __tests__ folders.
    • Files with .test.js suffix.
    • Files with .spec.js suffix.

    The .test.js / .spec.js files (or the __tests__ folders) can be located at any depth under the src top level folder.

    We recommend to put the test files (or __tests__ folders) next to the code they are testing so that relative imports appear shorter. For example, if App.test.js and App.js are in the same folder, the test just needs to import App from './App' instead of a long relative path. Colocation also helps find tests more quickly in larger projects.

    Command Line Interface

    When you run npm test, Jest will launch in the watch mode. Every time you save a file, it will re-run the tests, just like npm start recompiles the code.

    The watcher includes an interactive command-line interface with the ability to run all tests, or focus on a search pattern. It is designed this way so that you can keep it open and enjoy fast re-runs. You can learn the commands from the “Watch Usage” note that the watcher prints after every run:

    Jest watch mode

    Version Control Integration

    By default, when you run npm test, Jest will only run the tests related to files changed since the last commit. This is an optimization designed to make your tests run fast regardless of how many tests you have. However it assumes that you don’t often commit the code that doesn’t pass the tests.

    Jest will always explicitly mention that it only ran tests related to the files changed since the last commit. You can also press a in the watch mode to force Jest to run all tests.

    Jest will always run all tests on a continuous integration server or if the project is not inside a Git or Mercurial repository.

    Writing Tests

    To create tests, add it() (or test()) blocks with the name of the test and its code. You may optionally wrap them in describe() blocks for logical grouping but this is neither required nor recommended.

    Jest provides a built-in expect() global function for making assertions. A basic test could look like this:

    import sum from './sum';
     
    it('sums numbers', () => {
      expect(sum(1, 2)).toEqual(3);
      expect(sum(2, 2)).toEqual(4);
    });

    All expect() matchers supported by Jest are extensively documented here.
    You can also use jest.fn() and expect(fn).toBeCalled() to create “spies” or mock functions.

    Testing Components

    There is a broad spectrum of component testing techniques. They range from a “smoke test” verifying that a component renders without throwing, to shallow rendering and testing some of the output, to full rendering and testing component lifecycle and state changes.

    Different projects choose different testing tradeoffs based on how often components change, and how much logic they contain. If you haven’t decided on a testing strategy yet, we recommend that you start with creating simple smoke tests for your components:

    import React from 'react';
    import ReactDOM from 'react-dom';
    import App from './App';
     
    it('renders without crashing', () => {
      const div = document.createElement('div');
      ReactDOM.render(<App />, div);
    });

    This test mounts a component and makes sure that it didn’t throw during rendering. Tests like this provide a lot of value with very little effort so they are great as a starting point, and this is the test you will find in src/App.test.js.

    When you encounter bugs caused by changing components, you will gain a deeper insight into which parts of them are worth testing in your application. This might be a good time to introduce more specific tests asserting specific expected output or behavior.

    If you’d like to test components in isolation from the child components they render, we recommend using shallow() rendering API from Enzyme. To install it, run:

    npm install --save enzyme enzyme-adapter-react-16 react-test-renderer

    Alternatively you may use yarn:

    yarn add enzyme enzyme-adapter-react-16 react-test-renderer

    As of Enzyme 3, you will need to install Enzyme along with an Adapter corresponding to the version of React you are using. (The examples above use the adapter for React 16.)

    The adapter will also need to be configured in your global setup file:

    src/setupTests.js

    import { configure } from 'enzyme';
    import Adapter from 'enzyme-adapter-react-16';
     
    configure({ adapter: new Adapter() });

    Note: Keep in mind that if you decide to "eject" before creating src/setupTests.js, the resulting package.json file won't contain any reference to it. Read here to learn how to add this after ejecting.

    Now you can write a smoke test with it:

    import React from 'react';
    import { shallow } from 'enzyme';
    import App from './App';
     
    it('renders without crashing', () => {
      shallow(<App />);
    });

    Unlike the previous smoke test using ReactDOM.render(), this test only renders <App> and doesn’t go deeper. For example, even if <App> itself renders a <Button> that throws, this test will pass. Shallow rendering is great for isolated unit tests, but you may still want to create some full rendering tests to ensure the components integrate correctly. Enzyme supports full rendering with mount(), and you can also use it for testing state changes and component lifecycle.

    You can read the Enzyme documentation for more testing techniques. Enzyme documentation uses Chai and Sinon for assertions but you don’t have to use them because Jest provides built-in expect() and jest.fn() for spies.

    Here is an example from Enzyme documentation that asserts specific output, rewritten to use Jest matchers:

    import React from 'react';
    import { shallow } from 'enzyme';
    import App from './App';
     
    it('renders welcome message', () => {
      const wrapper = shallow(<App />);
      const welcome = <h2>Welcome to React</h2>;
      // expect(wrapper.contains(welcome)).to.equal(true);
      expect(wrapper.contains(welcome)).toEqual(true);
    });

    All Jest matchers are extensively documented here.
    Nevertheless you can use a third-party assertion library like Chai if you want to, as described below.

    Additionally, you might find jest-enzyme helpful to simplify your tests with readable matchers. The above contains code can be written more simply with jest-enzyme.

    expect(wrapper).toContainReact(welcome)

    To enable this, install jest-enzyme:

    npm install --save jest-enzyme

    Alternatively you may use yarn:

    yarn add jest-enzyme

    Import it in src/setupTests.js to make its matchers available in every test:

    import 'jest-enzyme';

    Using Third Party Assertion Libraries

    We recommend that you use expect() for assertions and jest.fn() for spies. If you are having issues with them please file those against Jest, and we’ll fix them. We intend to keep making them better for React, supporting, for example, pretty-printing React elements as JSX.

    However, if you are used to other libraries, such as Chai and Sinon, or if you have existing code using them that you’d like to port over, you can import them normally like this:

    import sinon from 'sinon';
    import { expect } from 'chai';

    and then use them in your tests like you normally do.

    Initializing Test Environment

    Note: this feature is available with react-scripts@0.4.0 and higher.

    If your app uses a browser API that you need to mock in your tests or if you just need a global setup before running your tests, add a src/setupTests.js to your project. It will be automatically executed before running your tests.

    For example:

    src/setupTests.js

    const localStorageMock = {
      getItem: jest.fn(),
      setItem: jest.fn(),
      clear: jest.fn()
    };
    global.localStorage = localStorageMock

    Note: Keep in mind that if you decide to "eject" before creating src/setupTests.js, the resulting package.json file won't contain any reference to it, so you should manually create the property setupTestFrameworkScriptFile in the configuration for Jest, something like the following:

    "jest": {
      // ...
      "setupTestFrameworkScriptFile": "<rootDir>/src/setupTests.js"
     }

    Focusing and Excluding Tests

    You can replace it() with xit() to temporarily exclude a test from being executed.
    Similarly, fit() lets you focus on a specific test without running any other tests.

    Coverage Reporting

    Jest has an integrated coverage reporter that works well with ES6 and requires no configuration.
    Run npm test -- --coverage (note extra -- in the middle) to include a coverage report like this:

    coverage report

    Note that tests run much slower with coverage so it is recommended to run it separately from your normal workflow.

    Configuration

    The default Jest coverage configuration can be overriden by adding any of the following supported keys to a Jest config in your package.json.

    Supported overrides:

    Example package.json:

    {
      "name": "your-package",
      "jest": {
        "collectCoverageFrom" : [
          "src/**/*.{js,jsx}",
          "!<rootDir>/node_modules/",
          "!<rootDir>/path/to/dir/"
        ],
        "coverageThreshold": {
          "global": {
            "branches": 90,
            "functions": 90,
            "lines": 90,
            "statements": 90
          }
        },
        "coverageReporters": ["text"],
        "snapshotSerializers": ["my-serializer-module"]
      }
    }

    Continuous Integration

    By default npm test runs the watcher with interactive CLI. However, you can force it to run tests once and finish the process by setting an environment variable called CI.

    When creating a build of your application with npm run build linter warnings are not checked by default. Like npm test, you can force the build to perform a linter warning check by setting the environment variable CI. If any warnings are encountered then the build fails.

    Popular CI servers already set the environment variable CI by default but you can do this yourself too:

    On CI servers

    Travis CI

    1. Following the Travis Getting started guide for syncing your GitHub repository with Travis. You may need to initialize some settings manually in your profile page.
    2. Add a .travis.yml file to your git repository.
    language: node_js
    node_js:
      - 6
    cache:
      directories:
        - node_modules
    script:
      - npm run build
      - npm test
    
    1. Trigger your first build with a git push.
    2. Customize your Travis CI Build if needed.

    CircleCI

    Follow this article to set up CircleCI with a Create React App project.

    On your own environment

    Windows (cmd.exe)
    set CI=true&&npm test
    set CI=true&&npm run build

    (Note: the lack of whitespace is intentional.)

    Windows (Powershell)
    ($env:CI = $true) -and (npm test)
    ($env:CI = $true) -and (npm run build)
    Linux, macOS (Bash)
    CI=true npm test
    CI=true npm run build

    The test command will force Jest to run tests once instead of launching the watcher.

    If you find yourself doing this often in development, please file an issue to tell us about your use case because we want to make watcher the best experience and are open to changing how it works to accommodate more workflows.

    The build command will check for linter warnings and fail if any are found.

    Disabling jsdom

    By default, the package.json of the generated project looks like this:

      "scripts": {
        "start": "react-scripts start",
        "build": "react-scripts build",
        "test": "react-scripts test --env=jsdom"

    If you know that none of your tests depend on jsdom, you can safely remove --env=jsdom, and your tests will run faster:

      "scripts": {
        "start": "react-scripts start",
        "build": "react-scripts build",
    -   "test": "react-scripts test --env=jsdom"
    +   "test": "react-scripts test"

    To help you make up your mind, here is a list of APIs that need jsdom:

    In contrast, jsdom is not needed for the following APIs:

    Finally, jsdom is also not needed for snapshot testing.

    Snapshot Testing

    Snapshot testing is a feature of Jest that automatically generates text snapshots of your components and saves them on the disk so if the UI output changes, you get notified without manually writing any assertions on the component output. Read more about snapshot testing.

    Editor Integration

    If you use Visual Studio Code, there is a Jest extension which works with Create React App out of the box. This provides a lot of IDE-like features while using a text editor: showing the status of a test run with potential fail messages inline, starting and stopping the watcher automatically, and offering one-click snapshot updates.

    VS Code Jest Preview

    Debugging Tests

    There are various ways to setup a debugger for your Jest tests. We cover debugging in Chrome and Visual Studio Code.

    Note: debugging tests requires Node 8 or higher.

    Debugging Tests in Chrome

    Add the following to the scripts section in your project's package.json

    "scripts"{
        "test:debug": "react-scripts --inspect-brk test --runInBand --env=jsdom"
      }

    Place debugger; statements in any test and run:

    $ npm run test:debug

    This will start running your Jest tests, but pause before executing to allow a debugger to attach to the process.

    Open the following in Chrome

    about:inspect
    

    After opening that link, the Chrome Developer Tools will be displayed. Select inspect on your process and a breakpoint will be set at the first line of the react script (this is done simply to give you time to open the developer tools and to prevent Jest from executing before you have time to do so). Click the button that looks like a "play" button in the upper right hand side of the screen to continue execution. When Jest executes the test that contains the debugger statement, execution will pause and you can examine the current scope and call stack.

    Note: the --runInBand cli option makes sure Jest runs test in the same process rather than spawning processes for individual tests. Normally Jest parallelizes test runs across processes but it is hard to debug many processes at the same time.

    Debugging Tests in Visual Studio Code

    Debugging Jest tests is supported out of the box for Visual Studio Code.

    Use the following launch.json configuration file:

    {
      "version": "0.2.0",
      "configurations": [
        {
          "name": "Debug CRA Tests",
          "type": "node",
          "request": "launch",
          "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/react-scripts",      
          "args": [
            "test",
            "--runInBand",
            "--no-cache",
            "--env=jsdom"
          ],
          "cwd": "${workspaceRoot}",
          "protocol": "inspector",
          "console": "integratedTerminal",
          "internalConsoleOptions": "neverOpen"
        }
      ]
    }
    

    Deployment

    npm run build creates a build directory with a production build of your app. Set up your favorite HTTP server so that a visitor to your site is served index.html, and requests to static paths like /static/js/main.<hash>.js are served with the contents of the /static/js/main.<hash>.js file.

    Serving Apps with Client-Side Routing

    If you use routers that use the HTML5 pushState history API under the hood (for example, React Router with browserHistory), many static file servers will fail. For example, if you used React Router with a route for /todos/42, the development server will respond to localhost:3000/todos/42 properly, but an Express serving a production build as above will not.

    This is because when there is a fresh page load for a /todos/42, the server looks for the file build/todos/42 and does not find it. The server needs to be configured to respond to a request to /todos/42 by serving index.html. For example, we can amend our Express example above to serve index.html for any unknown paths:

     app.use(express.static(path.join(__dirname, 'build')));
     
    -app.get('/', function (req, res) {
    +app.get('/*', function (req, res) {
       res.sendFile(path.join(__dirname, 'build', 'index.html'));
     });

    If you’re using Apache HTTP Server, you need to create a .htaccess file in the public folder that looks like this:

        Options -MultiViews
        RewriteEngine On
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteRule ^ index.html [QSA,L]
    

    It will get copied to the build folder when you run npm run build.

    If you’re using Apache Tomcat, you need to follow this Stack Overflow answer.

    Now requests to /todos/42 will be handled correctly both in development and in production.

    On a production build, and in a browser that supports service workers, the service worker will automatically handle all navigation requests, like for /todos/42, by serving the cached copy of your index.html. This service worker navigation routing can be configured or disabled by ejecting and then modifying the navigateFallback and navigateFallbackWhitelist options of the SWPreachePlugin configuration.

    When users install your app to the homescreen of their device the default configuration will make a shortcut to /index.html. This may not work for client-side routers which expect the app to be served from /. Edit the web app manifest at public/manifest.json and change start_url to match the required URL scheme, for example:

      "start_url": ".",

    Building for Relative Paths

    By default, Create React App produces a build assuming your app is hosted at the server root.
    To override this, specify the homepage in your package.json, for example:

      "homepage": "http://mywebsite.com/relativepath",

    This will let Create React App correctly infer the root path to use in the generated HTML file.

    Note: If you are using react-router@^4, you can root <Link>s using the basename prop on any <Router>.
    More information here.

    For example:

    <BrowserRouter basename="/calendar"/>
    <Link to="/today"/> // renders <a href="/calendar/today">

    Serving the Same Build from Different Paths

    Note: this feature is available with react-scripts@0.9.0 and higher.

    If you are not using the HTML5 pushState history API or not using client-side routing at all, it is unnecessary to specify the URL from which your app will be served. Instead, you can put this in your package.json:

      "homepage": ".",

    This will make sure that all the asset paths are relative to index.html. You will then be able to move your app from http://mywebsite.com to http://mywebsite.com/relativepath or even http://mywebsite.com/relative/path without having to rebuild it.

    S3 and CloudFront

    See this blog post on how to deploy your React app to Amazon Web Services S3 and CloudFront.

    Troubleshooting

    npm start doesn’t detect changes

    When you save a file while npm start is running, the browser should refresh with the updated code.
    If this doesn’t happen, try one of the following workarounds:

    • If your project is in a Dropbox folder, try moving it out.
    • If the watcher doesn’t see a file called index.js and you’re referencing it by the folder name, you need to restart the watcher due to a Webpack bug.
    • Some editors like Vim and IntelliJ have a “safe write” feature that currently breaks the watcher. You will need to disable it. Follow the instructions in “Adjusting Your Text Editor”.
    • If your project path contains parentheses, try moving the project to a path without them. This is caused by a Webpack watcher bug.
    • On Linux and macOS, you might need to tweak system settings to allow more watchers.
    • If the project runs inside a virtual machine such as (a Vagrant provisioned) VirtualBox, create an .env file in your project directory if it doesn’t exist, and add CHOKIDAR_USEPOLLING=true to it. This ensures that the next time you run npm start, the watcher uses the polling mode, as necessary inside a VM.

    If none of these solutions help please leave a comment in this thread.

    npm test hangs on macOS Sierra

    If you run npm test and the console gets stuck after printing react-scripts test --env=jsdom to the console there might be a problem with your Watchman installation as described in facebookincubator/create-react-app#713.

    We recommend deleting node_modules in your project and running npm install (or yarn if you use it) first. If it doesn't help, you can try one of the numerous workarounds mentioned in these issues:

    It is reported that installing Watchman 4.7.0 or newer fixes the issue. If you use Homebrew, you can run these commands to update it:

    watchman shutdown-server
    brew update
    brew reinstall watchman
    

    You can find other installation methods on the Watchman documentation page.

    If this still doesn’t help, try running launchctl unload -F ~/Library/LaunchAgents/com.github.facebook.watchman.plist.

    There are also reports that uninstalling Watchman fixes the issue. So if nothing else helps, remove it from your system and try again.

    npm run build exits too early

    It is reported that npm run build can fail on machines with limited memory and no swap space, which is common in cloud environments. Even with small projects this command can increase RAM usage in your system by hundreds of megabytes, so if you have less than 1 GB of available memory your build is likely to fail with the following message:

    The build failed because the process exited too early. This probably means the system ran out of memory or someone called kill -9 on the process.

    If you are completely sure that you didn't terminate the process, consider adding some swap space to the machine you’re building on, or build the project locally.

    npm run build fails on Heroku

    This may be a problem with case sensitive filenames. Please refer to this section.

    Moment.js locales are missing

    If you use a Moment.js, you might notice that only the English locale is available by default. This is because the locale files are large, and you probably only need a subset of all the locales provided by Moment.js.

    To add a specific Moment.js locale to your bundle, you need to import it explicitly.
    For example:

    import moment from 'moment';
    import 'moment/locale/fr';

    If import multiple locales this way, you can later switch between them by calling moment.locale() with the locale name:

    import moment from 'moment';
    import 'moment/locale/fr';
    import 'moment/locale/es';
     
    // ...
     
    moment.locale('fr');

    This will only work for locales that have been explicitly imported before.

    npm run build fails to minify

    Some third-party packages don't compile their code to ES5 before publishing to npm. This often causes problems in the ecosystem because neither browsers (except for most modern versions) nor some tools currently support all ES6 features. We recommend to publish code on npm as ES5 at least for a few more years.


    To resolve this:
    1. Open an issue on the dependency's issue tracker and ask that the package be published pre-compiled.
    • Note: Create React App can consume both CommonJS and ES modules. For Node.js compatibility, it is recommended that the main entry point is CommonJS. However, they can optionally provide an ES module entry point with the module field in package.json. Note that even if a library provides an ES Modules version, it should still precompile other ES6 features to ES5 if it intends to support older browsers.
    1. Fork the package and publish a corrected version yourself.

    2. If the dependency is small enough, copy it to your src/ folder and treat it as application code.

    In the future, we might start automatically compiling incompatible third-party modules, but it is not currently supported. This approach would also slow down the production builds.

    Alternatives to Ejecting

    Ejecting lets you customize anything, but from that point on you have to maintain the configuration and scripts yourself. This can be daunting if you have many similar projects. In such cases instead of ejecting we recommend to fork react-scripts and any other packages you need. This article dives into how to do it in depth. You can find more discussion in this issue.

    Keywords

    none

    Install

    npm i jbl-ui-components

    DownloadsWeekly Downloads

    1

    Version

    0.1.0

    License

    none

    Unpacked Size

    68.2 kB

    Total Files

    6

    Last publish

    Collaborators

    • 27percent