open-index/open-npm huggingface dataset:
npm package: @runmeetly/async-component
Description: Dynamic Webpack module importing for React Components
Author: Peter Yamanaka
Latest version: 0.0.2

# async-component

AsyncComponent is a simple wrapper for loading React Components using
Javascript dynamic imports.

## Install

```shell script

$ npm i @runmeetly/async-component

$ yarn add @runmeetly/async-component

```

## Why

Dynamic module imports are the future of Javascript, and making it easy to
use inside of React - the leading Javascript framework - will help improve
the ecosystem overall.

See information like
[this](https://javascript.info/modules-dynamic-imports)
and
[this](https://2ality.com/2017/01/import-operator.html#loading-code-on-demand)
for more information.

## How

There are two ways to use Async components, `DefaultAsyncComponent`
and `NamedAsyncComponent`.

For `default` imports, instead of this:

```javascript
import React from "react";
import Code from "./path/to/Code";

export class App extends React.Component {
  render() {
    return <Code />;
  }
}
```

You can do this:

```javascript
import React from "react";
import { DefaultAsyncComponent } from "@runmeetly/async-component";

const AsyncCode = DefaultAsyncComponent(() => import("./path/to/Code"));

export class App extends React.Component {
  render() {
    return <AsyncCode />;
  }
}
```

For `named` imports, instead of this:

```javascript
import React from "react";
import { NamedCode } from "./path/to/Code";

export class App extends React.Component {
  render() {
    return <NamedCode />;
  }
}
```

You can do this:

```javascript
import React from "react";
import { NamedAsyncComponent } from "@runmeetly/async-component";

const AsyncNamedCode = NamedAsyncComponent(async () => {
  const module = await import("./path/to/Code");
  return module.NamedCode;
});

export class App extends React.Component {
  render() {
    return <AsyncNamedCode />;
  }
}
```

# Credit

`async-components` is primarily developed and maintained by
[Peter](https://github.com/pyamsoft) at
[Meetly](https://www.runmeetly.com).

# License

```
 Copyright 2019 Meetly Inc.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
```
npm package: @runmeetly/logger
Description: A simple logger
Author: Peter Yamanaka
Latest version: 0.0.2

# logger

A simple abstracted logger library

## Install

```shell script

$ npm i @runmeetly/logger

$ yarn add @runmeetly/logger

```

## Why

Instead of copy-pasting this class everywhere in all of the projects
we've turned it into a library. Here you go, have fun!

## How

Imagine you have some existing code, such as this:

```javascript
import { Logger, DebugLogger } from '@runmeetly/logger';

const IS_DEBUG_MODE = ... // decided by your environment

// The implementation of this key is not stable. Right now its a number, tomorrow it could be an object.
// Don't rely on it for anything but plant and uproot
let loggerKey = undefined;
if (IS_DEBUG_MODE) {
  // A DebugLogger will forward calls to the browser console.
  // It will also attempt to discover the source file that the call is coming from
  // and log it to the console as well if it can.
  loggerKey = Logger.plant(new DebugLogger());
}

Logger.log("Hello");
// prints 'Hello' in console only when IS_DEBUG_MODE is true
// no-op in production

Logger.warn("Uh-oh");
// prints 'Uh-oh' at warning level in console only when IS_DEBUG_MODE is true
// no-op in production

Logger.error("Oh-no");
// prints 'Oh-no' at error level in console only when IS_DEBUG_MODE is true
// no-op in production

if (loggerKey) {
  // uproot() will return true if it uprooted something and false if it did not.
  Logger.uproot(loggerKey)
}

// Plant anything you want
Logger.plant(new MixpanelLogger());
Logger.plant(new MySpecialLogger());
Logger.plant(new OnlyLogOnTuesdays());
```

Anything can be planted as a Logger implementation as long as it has the methods
`log` `debug` `warn` `info` `error`. By default this library only ships with a
`DebugLogger` implementation, but you can create your own implementations to do
things like call through to analytics services or crash reporting.

# Credit

`Logger` is primarily developed and maintained by
[Peter](https://github.com/pyamsoft) at
[Meetly](https://www.runmeetly.com).

# License

```
 Copyright 2020 Meetly Inc.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
```