open-index/open-npm huggingface dataset:
npm package: @multiprocess/preview
Description: A large-object previewer for JavaScript
Author: Phil Eaton
Latest version: 0.2.3

# Preview

This library helps showing snippets of large or small objects. It is
particularly useful when trying to render snippets of very large
objects.

## Install

```bash
$ yarn add https://github.com/multiprocessio/preview
```

## Examples

While this library is a huge improvement on naive implementations like
`JSON.stringify(x).slice(0, 1000)` for large objects (say 70,000
elements), it's easier to show a small object in an example. So we'll
display a small object but overwrite `preview`'s default number of
results to show.

```javascript
import { preview } from 'preview';

// The default is 20, so we make it smaller.
const startingNumber = 2;

console.log(preview([
  { a: 1, b: 3, c: 5 },
  { a: 12, b: 8, c: 5 },
  { a: 13, b: 3, c: 9 },
], startingNumber));
```

Once it reaches the starting number of keys, it stops printing
elements. As it recurses into inner objects, the number of keys
shrinks each time as well.

Here is the output of the above script:

```json
[
  { "a": 1, ... },
  { "a": 12, ... },
  ...
]
```

Ellipsis are literally printed. They are only printed if elements have
been skipped by the preview.

### Another example

Here is another example of a more complex object:

```
import { preview } from 'preview';

const startingNumber = 4;
console.log(preview(
  { a: 12, b: [1, 3, 4], c: null, d: { n: 'foo', m: 19, l: [12] } },
  startingNumber,
))
```

And the result:

```json
{
  "a": 12,
  "b": [ 1, 3, ... ],
  "c": null,
  "d": { "l": [ 12 ], "m": 19, ... }
}
```

Here, ellipsis only show up in the inner objects and not the outer
object because no keys in the outer object were skipped. There were
only four keys and the starting number of keys was four.

## Still confused?

For more details, check out this [blog
post](https://datastation.multiprocess.io/blog/2021-07-15-writing-an-efficient-javascript-object-previewer.html).

## Where did this come from?

This library is used by
[DataStation](https://github.com/multiprocessio/datastation), an
open-source data IDE, to show previews of objects of arbitrary size.

## License

Apache-2.0, see [./LICENSE.md](./LICENSE.md).
npm package: @multiprocess/shape
Description: Basic schema inference for arbitrary JavaScript data objects
Author: Phil Eaton
Latest version: 0.2.2

# Shape

This library provides an inference of object shape given a JavaScript
data object. It probably won't work well with circular references. But
any object that comes from JSON will not have circular references.

It works well on very small or very large objects due to sampling
(which can be turned off if requested).

You can try it out online in the [DataStation app](https://app.datastation.multiprocess.io/).

![screenshot](./screenshot.png)

## Install

```bash
$ yarn add https://github.com/multiprocessio/shape
```

## Examples

```javascript
import { shape, toString } from 'shape';

const schema = shape({
  "results": [
    { "name": "Kevin", "score": "1" },
    { "name": "Moira", "score": 1 },
    { "name": "Alexei", "score": 2 },
    { "name": "Tia", "score": 2, "admin": true }
  ],
  "pageSize": 5,
  "total": 100,
  "nextPage": "https://myapi.com/p=2",
});
console.log(JSON.stringify(schema, null, 2), toString(schema));
```

Will print out:

```
{    
  "kind": "object",
  "children": {
    "results": {
      "kind": "array",
      "children": {
        "kind": "object",
        "children": {
          "name": {
            "kind": "scalar",
            "name": "string"
          },      
          "score": {
            "kind": "varied",
            "children": [
              {
                "kind": "scalar",
                "name": "string"
              },
              {
                "kind": "scalar",
                "name": "number"
              }
            ]
          },
          "admin": {
            "kind": "scalar",
            "name": "boolean"
          }
        }
      }
    },
    "pageSize": {
      "kind": "scalar",
      "name": "number"
    },
    "total": {
      "kind": "scalar",
      "name": "number"
    },
    "nextPage": {
      "kind": "scalar",
      "name": "string"
    },
  }
} Object with
  'results' of
    Array of
      Object with
        'name' of
          string,
        'score' of
          string or
          number,
        'admin' of
          boolean,
  'pageSize' of
    number,
  'total' of
    number,
  'nextPage' of
    string
```

## Sampling

This library defaults to checking up to only 5000 elements at any
level which allows the inferrence to scale to very large datasets. It
will pick up to N elements randomly with the object to sample. To
disable this, pass `null`, `undefined`, or `false` as the second
argument to `shape`. For example `shape(data, false)`.

However, turning off sampling will eventually wreck your stack as you
pass bigger objects to `shape`.

## License

Apache-2.0, see [./LICENSE.md](./LICENSE.md).