open-index/open-npm huggingface dataset:
npm package: @qualialabs/generator-qualia-meteor
Description: Generate Qualia-style Blaze templates
Author: Travis Geis
Latest version: 1.0.4

# generator-qualia-meteor
Generate Qualia-style Blaze templates

## Install

```
npm install -g yo @qualialabs/generator-qualia-meteor
```

## Usage

### Create a template

```
cd dir/in/which/to/create/templates
yo @qualialabs/qualia-meteor:template
```

Enter the name of your template to generate it:

```
? New template name myTemplateName
   create my_template_name.html
   create my_template_name.js
   create my_template_name.css
```

### Create a Meteor package

```
cd dir/in/which/to/create/package-files
yo @qualialabs/qualia-meteor:package
```

Answer the prompts to generate your package files:

```
? Full package name (e.g. qualia:lasr) qualia:test
? Brief summary This is a test
   create package.js
   create README.md
   create client/main.js
   create server/main.js
```
npm package: @qualified/attach
Description: Attach local files to Qualified challenge
Author: kazk
Latest version: 0.5.1

## qualified-attach

[![Version](https://img.shields.io/npm/v/@qualified/attach.svg)](https://npmjs.org/package/@qualified/attach)
[![Downloads/week](https://img.shields.io/npm/dw/@qualified/attach.svg)](https://npmjs.org/package/@qualified/attach)
[![License](https://img.shields.io/npm/l/@qualified/attach.svg)](https://gitlab.com/qualified/attach/blob/master/package.json)

<!-- toc -->

- [Usage](#usage)
  <!-- tocstop -->

# Usage

<!-- usage -->

```sh-session
$ npm install -g @qualified/attach

$ qualified-attach
set up local workspace...

$ qualified-attach --help
Attach local files to Qualified challenge

USAGE
  $ qualified-attach

OPTIONS
  -h, --help         show help
  -t, --token=token  token provided by web IDE
  -v, --version      show version
...
```

<!-- usagestop -->
npm package: @qualified/ccc-files
Description: Provides a function to map ClassicCodeChallenge fields to files
Author: kazk
Latest version: 0.2.1

# @qualified/ccc-files

Provides a function to map ClassicCodeChallenge fields to files.

```typescript
type FileWithSource = {
  path: string;
  contents: string;
  source: "solution" | "tests" | "preloaded" | "generated";
};

type ClassicCodeChallenge = {
  preloaded?: string;
  solution: string;
  tests: string;
  language: string;
  languageVersion?: string;
  testFramework: string;
  preset?: string;
};

type Options = {
  /**
   * For paths based on the field value, fall back to a predefined path instead of
   * throwing an error on invalid value.
   */
  fallback?: boolean;
};

const toFiles: (ccc: ClassicCodeChallenge, opts?: Options) => FileWithSource[];
```

## Supported Languages

- C#
- Dart
- Java
- JavaScript
- Python
- Ruby
- TypeScript

## Usage

```typescript
import { toFiles } from "@qualified/ccc-files";

const preloaded = `
package example;

public class Preloaded {}
`;
const solution = `
package example;

public class Example {}
`;
const tests = `
package example;

class ExampleTests {}
`;

toFiles({
  preloaded,
  solution,
  tests,
  language: "java",
  languageVersion: "17",
  testFramework: "junit",
});
```

```javascript
[
  {
    path: "src/test/java/example/ExampleTests.java",
    contents: "...",
    source: "tests",
  },
  {
    path: "src/main/java/example/Example.java",
    contents: "...",
    source: "solution",
  },
  {
    path: "src/main/java/example/Preloaded.java",
    contents: "...",
    source: "preloaded",
  },
];
```
npm package: @qualified/codemirror-bundled
Description: Bundles `codemirror` and `@qualified/codemirror-workspace` into a single ESM.
Author: kazk
Latest version: 0.2.2

# @qualified/codemirror-bundled

Bundles `codemirror` and `@qualified/codemirror-workspace` into a single ESM.

- Bundled: `bundled/index.js`
- CJS: `lib/index.js`
- ESM: `src/index.js`
npm package: @qualified/codemirror-workspace
Description: Provides intelligence to CodeMirror editors
Latest version: 0.5.0

# @qualified/codemirror-workspace

Provides intelligence to CodeMirror editors.

`Workspace` is an abstraction to allow CodeMirror editors to use Language Servers.

## Usage Example

```typescript
import { Workspace } from "@qualified/codemirror-workspace";

const workspace = new Workspace({
  // Project root. Required.
  rootUri: "file:///workspace/",

  // Provide language associaton (language id and server ids) for URI. Required.
  getLanguageAssociation: (uri: string) => {
    // javascript, javascriptreact, typescript, typescriptreact
    if (/\.(?:[jt]sx?)$/.test(uri)) {
      const languageId = /\.tsx?$/.test(uri) ? "typescript" : "javascript";
      return {
        languageId: languageId + (uri.endsWith("x") ? "react" : ""),
        languageServerIds: ["typescript-language-server"],
      };
    }

    const styles = uri.match(/\.(css|less|s[ac]ss)$/);
    if (styles !== null) {
      return {
        languageId: styles[1],
        languageServerIds: ["css-language-server"],
      };
    }

    if (uri.endsWith(".html")) {
      return {
        languageId: "html",
        languageServerIds: ["html-language-server"],
      };
    }

    if (uri.endsWith(".json")) {
      return {
        languageId: "json",
        languageServerIds: ["json-worker"],
      };
    }

    // Return null to let the workspace ignore this file.
    return null;
  },

  // Provide the server's connection string. Required.
  // The returned string can be a URI of WebSocket proxy or
  // a location of Worker script to start Language Server.
  getConnectionString: async (langserverId: string) => {
    switch (langserverId) {
      case "typescript-language-server":
        // Use some API to start remote Language Server and return a string.
        const res = await fetch("/start", { method: "POST" });
        return res.json().uri;

      case "css-language-server":
        // Return an endpoint of already running proxy.
        return "ws://localhost:9991";

      case "html-language-server":
        return "ws://localhost:9992";

      case "json-worker":
        // Return a location of a script to start Language Server in Web Worker.
        return "js/json-worker.js";

      default:
        return "";
    }
  },

  // Optional function to return HTML string from Markdown.
  renderMarkdown: (markdown: string): string => markdown,
});
// Open text document in workspace to enable code intelligence.
// `cm` is CodeMirror.Editor instance with contents of the file.
workspace.openTextDocument("example.js", cm);
```

## Prior Art

- [`lsp-editor-adapter`] by [@wylieconlon]

[`lsp-editor-adapter`]: https://github.com/wylieconlon/lsp-editor-adapter
[@wylieconlon]: https://github.com/wylieconlon
npm package: @qualified/vscode-snippet-parser
Description: [vs/editor/contrib/snippet/snippetParser.ts][snippetparser] extracted and modified from [vscode] codebase.
Latest version: 0.1.0

# @qualified/vscode-snippet-parser

[vs/editor/contrib/snippet/snippetParser.ts][snippetparser] extracted and modified from [vscode] codebase.

## License

[MIT](./LICENSE.md) Copyright (c) Microsoft Corporation / Qualified, Inc

[vscode]: https://github.com/microsoft/vscode
[snippetparser]: https://github.com/microsoft/vscode/blob/1ace7f22a63c8e8a6df61845f524af1d564a0953/src/vs/editor/contrib/snippet/snippetParser.ts
[charcode]: https://github.com/microsoft/vscode/blob/1ace7f22a63c8e8a6df61845f524af1d564a0953/src/vs/base/common/charCode.ts
npm package: @qualifyze/airtable-formulator
Description: Airtable Formula Manipulator
Latest version: 1.3.1

# @qualifyze/airtable-formulator

## What?

A library that allows you to formulate airtable formulas in a structured rather
than unstructured notation.

Example `AND({name}="Robert",{age}>35)`:

```ts
import { Formula } from "airtable-formulator";

const formula: Formula = [
  "AND",
  ["=", { field: "name" }, "Robert"],
  [">", { field: "age" }, 35],
];
```

## Why?

- To allow TypeScript detect problems with a formula at build time.
- To validate a formula at runtime, using JSON Schema, before it gets sent to the Airtable API.
- For easy runtime manipulations of formulae without risking a code injection vulnerability.

## How?

### Install

```
npm install @qualifyze/airtable-formulator
```

### Use

Validate formula:

```ts
import { validate } from "airtable-formulator";

const validationErrors = validate(formula);

if (validationErrors.length > 0) {
  throw new Error(
    `Invalid Formula: ${JSON.stringify(validationErrors, null, 2)}`
  );
}
```

Compile formula:

```ts
import { compile } from "airtable-formulator";

const formulaStr = compile(formula);
```

Parse a string formula (experimental):

```ts
import { parse } from "airtable-formulator";

const formula = parse("AND({name}=\"Robert\",{age}>35)");
```

The above will yield:

```ts
[
  "AND",
  ["=", { field: "name" }, "Robert"],
  [">", { field: "age" }, 35],
]
```

### Maintain

If Airtable expends their library of functions and operators that can be used in formulae, run:

```
npm run update-reference
```

This will update the JSON manifest that lists all available functions and operators.

### Experimental AST Parser

The AST parser is still experimental in the sense it should not be used for critical applications.

```ts
import { ast } from "airtable-formulator";
const output = ast.parse("IF({name}='Robert',{age},0)");
```

The parser will for now only output an abstract syntax tree. It will not yet convert it into an object notation formula

The syntax tree for the parser above returns an object that matches this:

```json
{
  "type": "functionCall",
  "reference": {
    "value": "IF"
  },
  "argumentList": {
    "args": [
      {
        "type": "operation",
        "left": {
          "type": "fieldReference",
          "value": "name"
        },
        "operator": {
          "value": "="
        },
        "right": {
          "type": "string",
          "value": "Robert"
        }
      },
      {
        "type": "fieldReference",
        "value": "age"
      },
      {
        "type": "number",
        "value": 0
      }
    ]
  }
}
```

Note that each object above also contains positional information about the location of the token in the formula string.

```json
{
  "type": "operator",
  "value": "=",
  "start": 9,
  "end": 10
}
```
npm package: @qualifyze/design-system
Description: Qualifyze Design System
Latest version: 3.2.2

# Design System

A place to develop React components in a sandboxed environment.

## Docs

- [Core concepts](./docs/CORE-CONCEPTS.md)
- [System Props](./docs/SYSTEM-PROPS.md)
- [FAQ](./docs/FAQ.md)

## Getting Started

- Install [Volta](https://volta.sh/)
- Install all dependencies with `npm ci`
- Run Storybook with `npm start`, it will open automatically in your browser.

## Fonts

You need to include the new fonts from `@qualifyze/mui-theme`:

```
import "@qualifyze/mui-theme/fonts/everett/index.css"
import "@qualifyze/mui-theme/fonts/tobias/index.css"
```

## Dependencies

The design system has a dependency on globalThis so if you are using the design system you need to either install a npm package like [globalthis](https://www.npmjs.com/package/globalthis). Or if you have access to core-js in your project you can solve the dependency like this:

```js
import 'core-js/features/global-this'
```

In your app entry where you would normally apply other polyfills.

## Z-Indices

This project includes several components that have to work even when they are layered on top of each other. To not mess up the order in which they should appear on screen, let's collect all relevant values for `z-index` here.

| Component                    | `z-index` |
| ---------------------------- | --------- |
| Header (in `website`)        | 50        |
| Cookie Banner (in `website`) | 900       |
| Notification                 | ???       |
| Modal                        | 500       |

## Limitations and known issues

### Stack, Inline, Tiles and Columns components with large `space` prop values

Child components of `Stack`, `Inline`, `Tiles` and `Columns` might "leak" into other components if values above 4 are given to it in the `space` prop, blocking interaction with other UI elements like buttons or text.

Workaround is to wrap the component that "leaks" and the one "leaked into" in `Box` or `Flex` components and provide `z-index` for both.
For example, with a `Stack` component:

```jsx
import Box from '@qualifyze/design-system'

function App() {
  return (
    <Box>
      <Box sx={{ zIndex: 2 }}>
        <Button>You can't click Me!</Button>
      </Box>
      <Box sx={{ zIndex: 1 }}>
        <Stack space={5}>
          <Button>Just a regular button</Button>
        </Stack>
      </Box>
    </Box>
  )
}
```

For examples of how these components can leak, check their stories in storybook under "leaking example". So far, `Stack` is the only one who has actually given trouble and the only example taken from the platform.

Fixing this requires a major version release because we still need to support [Internet Explorer](https://death-to-ie11.com/).
npm package: @qualipool/swissrets-json
Description: A swiss real estate transfer standard.
Author: Vereinigung Qualipool
Latest version: 3.1.0

[![GitHub package version](https://img.shields.io/github/release/qualipool/swissrets-json.svg)](https://github.com/qualipool/swissrets-json/releases)
[![build](https://github.com/qualipool/swissrets-json/actions/workflows/pr.yml/badge.svg)](https://github.com/qualipool/swissrets-json/actions?query=workflow%3Apr)
[![GitHub](https://img.shields.io/github/license/qualipool/swissrets.svg)](https://github.com/qualipool/swissrets/blob/master/LICENSE.md)

SwissRETS JSON
=========
SwissRETS is a swiss real estate transaction standard. It aims to solve data exchange between real estate software and platforms. It's meant to be a replacement for old and static formats like the widely used [IDX 3.01](https://en.wikipedia.org/wiki/Internet_Data_Exchange) in Switzerland.

This repository is a fork of the XML-based repository https://github.com/qualipool/swissrets. The primary development of the standard will take place here, while we aim to maintain the XML standard without introducing new features.

Check out the schema [documentation](https://qualipool.github.io/swissrets-json/).

## NPM Package

### Referencing the package

* Add the package with `npm add @qualipool/swissrets-json`

### Using the typescript schema validator

```ts
import {
    validateSwissRets,
    SwissRetsInventory
} from '@qualipool/swissrets-json';

// validating a SwissRETS JSON string
const stringValue = `{
    "created": "2023-03-23T08:11:12Z",
    "generator": {
        "name": "CASAGATEWAY",
        "version": "0.9"
    },
    "properties": []
    }`;
const result = validateSwissRets(Value);
console.log(result);

// validating a SwissRETS JSON object
const srObject: SwissRetsInventory = {
    created: '2023-03-23T08:11:12Z',
    generator: {
        name: 'CASAGATEWAY',
        version: '0.9'
    },
    properties: []
};

result = validateSwissRets(srObject);
console.log(result);
```

## Code of conduct

Please review and follow the [Code of conduct](./CODE_OF_CONDUCT.md).

Please report any unacceptable behaviour to the maintainers.

## Migration from XML to JSON standard

Find the guidelines for the migration from the XML standard in the [Migration Guide](./MIGRATION-GUIDE.md).

## License

[MIT](./LICENSE.md)
npm package: @qualitech/qecm
Description: Utilitário de upload e download de arquivos do AWS S3
Author: Arthur Santos
Latest version: 1.0.5

# @qualitech/qecm

Utilitário de upload e download de arquivos do AWS S3

## Começando

Instanciando o utilitário

```js
const FileUploader = '@qualitech/qecm';

const fileUploader = new FileUploader({
  url: "http://localhost:PORT",
  apiKey: "APP_KEY_GRAVITEE",
  token: "SEU_TOKEN_DE_ACESSO"
})
```

### Download

```js
await fileUploader.download("CAMINHO/DO/ARQUIVO.EXT", "NOME_POS_DOWNLOAD.EXT")
```

### Upload

```js
const input = document.getElementById('input')
const arquivo = input.files[0]

await fileUploader.upload("CAMINHO/DO/ARQUIVO.EXT", arquivo)
```

### URL de Download temporária

```js
const url = await fileUploader.getDownloadURL("CAMINHO/DO/ARQUIVO.EXT")
```
npm package: @qualitech/v-clipboard
Description: Vue.js Clipboard Plugin
Author: euvl
Latest version: 2.3.0

[![npm version](https://badge.fury.io/js/v-clipboard.svg)](https://badge.fury.io/js/v-clipboard)

## Vue.js Clipboard

### Install

```bash
npm install --save v-clipboard
```

```javascript
import Vue from 'vue'
import Clipboard from 'v-clipboard'

Vue.use(Clipboard)
```

### Using

> When an element that contains `v-clipboard` directive is clicked, the value of `value` will be copied into clipboard.

Copying **static** value (directive should receive actual value):

```vue
<button v-clipboard="value">
  Copy to clipboard
</button>
```

Copying **dynamic** value (directive should recieve a function that returns value):

```vue
<button v-clipboard="() => value">
  Copy to clipboard
</button>
```

Copying **anything** in your methods:

```js
this.$clipboard(value)
```

### Events

```vue
<button v-clipboard="foo"
        v-clipboard:success="clipboardSuccessHandler" // Success event handler
        v-clipboard:error="clipboardErrorHandler">    // Error event handler
  Copy to clipboard
</button>
```

```js
{
  methods: {
    clipboardSuccessHandler ({ value, event }) {
      console.log('success', value)
    },

    clipboardErrorHandler ({ value, event }) {
      console.log('error', value)
    }
  }
}
```

### Compatibility

<p align="center">
  <img src="https://user-images.githubusercontent.com/1577802/28269902-8ae0e01e-6afb-11e7-9981-d4965bac69d1.png">
</p>