open-index/open-npm huggingface dataset:
npm package: @nlibs/kvlite
Description: kvlite is an in-memory key value store with an sqlite backend.
Latest version: 0.0.10

# kvlite

kvlite is an in-memory key value store with an sqlite backend.

# Installation

	npm install kvlite

# API

kvlite has 3 call 

- constructor(path: string, oncomplete)
- get(key: string, oncomplete(value: string)=>void);
- set(key: string, value: string);

## Example

	var KVLITE = require("kvlite");
	var db = new KVLITE.kv("path");
	db.set("key", "value");
	db.get("key", function(value)
	{
		if (typeof value == 'undefined')
		{
			//  key not found
		}
	});
npm package: @nlighten/json-schema-utils
Description: Various utilities for handling JSON Schemas (parse, join, generate, samples)
Author: Eli Sherer
Latest version: 1.1.0

# json-schema-utils

![](https://img.shields.io/npm/v/@nlighten/json-schema-utils.svg)
[![Build](https://github.com/nlighten-oss/json-schema-utils/actions/workflows/pr-tests.yml/badge.svg)](https://github.com/nlighten-oss/json-schema-utils/actions/workflows/pr-tests.yml)

Various utilities for handling JSON Schemas (parse, join, generate, samples)

# Installation

`npm install @nlighten/json-schema-utils`

# API

```typescript
JSONSchemaUtils: {
    join: (pathsDescriptors: { targetPath: string; type: TypeSchema; }[], options?: JoinOptions) => TypeSchema;
    parse: (schema: TypeSchema, options?: ParsingOptions) => ParsedSchema;
    generate: (value: any, options?: GenerateSchemaOptions) => TypeSchema;
};

```

# License
[MIT](./LICENSE)
npm package: @nlighten/json-transform
Description: JSON transformers JavaScript implementation
Author: Eli Sherer
Latest version: 1.9.0

# @nlighten/json-transform

![](https://img.shields.io/npm/v/@nlighten/json-transform.svg)

[JSON transformers](https://nlighten-oss.github.io/json-transform/) JavaScript implementation (~20kB)

# Installation

`npm install @nlighten/json-transform`

# Usage

```typescript
(async() => { // in an async context
  
  const transformer = new JsonTransformer("$$lower:$.x")
  expect(
    await transformer.transform({x: "HELLO"})
  ).toEqual("hello");
  
})();
```

# Peer dependencies
Notice the following peer dependencies that are required by some of the functions:
 - fast-json-patch
 - js-yaml
 - json-pointer
 - xml2js

# License
[MIT](./LICENSE)
npm package: @nlighten/json-transform-core
Description: Core types and utilities for handling JSON transformers
Author: Eli Sherer
Latest version: 1.9.1

# @nlighten/json-transform-core

![](https://img.shields.io/npm/v/@nlighten/json-transform-core.svg)

Core types and utilities for handling JSON transformers

# Installation

`npm install @nlighten/json-transform-core`

# API

```typescript
{
  ContextVariablesSchemas: Record<string, TypeSchema>,
  getFunctionInlineSignature:  (name: string, func: FunctionDescriptor, requiredOnly?: boolean) => string,
  getFunctionObjectSignature:  (name: string, func: FunctionDescriptor) => string,
  functionsParser:  {
    get(name: string) => FunctionDescriptor,
    getNames() => Set<string>,
    resolveDocsUrl(funcName: string, functionDescriptor ? : FunctionDescriptor) => string,
    matchInline(
      data: any,
      callback?: (
        funcName: EmbeddedTransformerFunction,
        func: FunctionDescriptor,
        value: any,
        args: Record<string, any>,
      ) => any): FunctionDescriptor | null,
    matchObject(data: any, extractOutputTypeRecursively ? : boolean):ObjectFunctionMatchResult | undefined,
    matchAllObjectFunctionsInLine(line: string) => IterableIterator,
    matchAllInlineFunctionsInLine(line: string) => IterableIterator,
  },
  parseArgs: (func: FunctionDescriptor, args?: string) => {},
  type Argument,
  type ArgumentCondition,
  type ConditionalSubFunction,
  type FunctionDefinition,
  type FunctionDescriptor,
  EmbeddedTransformerFunction, // enum
  EmbeddedTransformerFunctions: EmbeddedTransformerFunction[],
  type JsonTransformExample,
  jsonpathJoin: (...args: (string | null | undefined)[]): string,
  JsonPathFunctionRegex: RegExp,
  parseTransformer: (
    definition: any,
    targetPath: string,
    previousPaths: string[],
    paths: string[] = [],
    typesMap? : Record<string, TypeSchema>,
    additionalContext? : Record<string, TypeSchema>,
  ) => void,
  ParseContext: {
    resolve(name: string) => TypeSchema,
  },
  type ParseMethod,
  type HandleFunctionMethod,
  definitions: Record<EmbeddedTransformerFunction, FunctionDefinition>,
  examples: Record<EmbeddedTransformerFunction, JsonTransformExample>,
  functions: Record<EmbeddedTransformerFunction, FunctionDescriptor>, 
  transformUtils: { //TransformUtils
    setAdditionalContext: (additionalContext: Set<string>) => void,
    getAdditionalContext: () => Set<string>,
    setSpecialKeys: (specialKeys: Set<string>) => void,
    getSpecialKeys: () => Set<string>,
    setContextVariablesSchemas: (contextVariablesSchemas: Record<string, TypeSchema>) => void,
    getContextVariablesSchemas: () => Record<string, TypeSchema>,
    setScopedContextVariablesSchema: (scopedContextVariablesSchema: Record<string, TypeSchema | null>) => void,
    getScopedContextVariablesSchema: () => Record<string, TypeSchema | null>,
    matchesAnyOfContextVariables: (variableName: string) => boolean,
    matchesAnyOfAdditionalContext: (variableName: string) => boolean,
    matchesAnyOfSpecialKeys: (variableName: string) => boolean,
    variableDetectionRegExpFactory: (flags = "g") => RegExp,
  }
}
;

```

# License
[MIT](./LICENSE)
npm package: @nlighten/monaco-json-transform
Description: JSON Transform language tokenizer (and syntax highlight), hover provider and more
Author: Eli Sherer
Latest version: 1.9.0

# monaco-json-transform

[Monaco Editor](https://github.com/microsoft/monaco-editor) JSON Transform language tokenizer (and syntax highlight), hover provider and more.

## Installation

- `npm i -S @nlighten/monaco-json-transform`

## Usage

With a helper function to register straight to monaco
```js
// `monaco` should be global or local in the loading module

import {
  registerJsonTransformItemCompletionProvider,
  registerJsonTransformDSTProvider,
  registerJsonTransformHoverProvider,
  defineThemeVsDarkCustom,
} from "@nlighten/monaco-json-transform";

...

registerJsonTransformDSTProvider(monaco);

registerJsonTransformItemCompletionProvider(monaco, {
  getTypeMap: model => { // example
    const path = model.uri.path;
    const [, paths] = getSuggestions(path);
    return paths;
  },
  getSuggestions: model => { // example
    const path = model.uri.path;
    return getSuggestions(path)[0];
  },
});

registerJsonTransformHoverProvider(monaco, {
  getTypeMap: model => { // example
    const path = model.uri.path;
    return getSuggestions(path, true)[1];
  },
});

defineThemeVsDarkCustom(monaco);
```


For syntax highlighting, in monaco editor, use `"vs-dark-custom"` (or your value if changed) as `theme`.

## License

monaco-json-transform is [MIT Licensed](https://github.com/elisherer/monaco-languages-json-transform/blob/master/LICENSE)
npm package: @nliveris/use-sw-quote
Description: >
Author: NicolasLiveris
Latest version: 1.0.0

# @nliveris/use-sw-quote

> 

[![NPM](https://img.shields.io/npm/v/@nliveris/use-sw-quote.svg)](https://www.npmjs.com/package/@nliveris/use-sw-quote) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save @nliveris/use-sw-quote
```

## Usage

```jsx
import React from 'react'
import { useStarWarsQuote } from '@nliveris/use-sw-quote'

const App = () => {
  const { quote, loading } = useStarWarsQuote()
  if (loading) return <p>Loading ...</p>
  if (quote) return <p>{quote}</p>
  return null
}

export default App

```

## License

MIT © [NicolasLiveris](https://github.com/NicolasLiveris)

---

This hook is created using [create-react-hook](https://github.com/hermanya/create-react-hook).