open-index/open-npm huggingface dataset:
npm package: @gushen610140/hucky
Description: hucky 是一个简单的脚手架工具，用于快速创建项目。
Latest version: 0.1.0

# hucky

## 介绍

hucky 是一个简单的脚手架工具，用于快速创建项目。

## 使用方法

```bash
npm install -g @gushen610140/hucky
```

```bash
hucky create <project-name>
```

## 模板列表

- template-vue-hucky
npm package: @gushogg-blake/flowfs
Description: Filesystem abstraction that attempts to not block your flow
Latest version: 5.1.2

flowfs
======

I wrote flowfs because I could never remember the names and signatures of the `fs` and related APIs, and because manipulating paths as strings is awkward and error-prone.  Dealing with files was always a point where I would be knocked out of the zone by having to refer to docs, and run throwaway tests to make sure I was doing it right.

flowfs attempts to solve these issues by exposing an intuitive API that represents files as objects.  Navigation between nodes is via properties; for example, if you're implementing an "include" directive for a template language and need to calculate a relative path -- instead of this:

```javascript
// old, bad, awkward, error-prone, annoying, hard-to-remember way:

const fs = require("fs");
const path = require("path");

function include (templatePath, includePath) {
	let parent = fs.dirname(templatePath);
	
	return path.resolve(parent, includePath); // or something
}
```

... you would do this:

```javascript
// flowfs way:

const fs = require("flowfs");

function include (templatePath, includePath) {
	return fs(templatePath).parent.child(includePath).path;
}
```

Instantiating and navigating between nodes doesn't do any IO, it just does string manipulation internally -- `fs("/path/to/non-existent/file")` is perfectly valid, and is the recommended way to create new files with flowfs, for example:

```javascript
await fs("/new/file").write("some data");
```
npm package: @gushogg-blake/prettier-config
Description: Prettier config
Author: Gus Hogg-Blake
Latest version: 1.0.0

Prettier config
===

This config enforces some suggestions for a simple way to approach code formatting, particularly when, how, and how much to indent.

Use tabs for indentation
---

Tabs are simpler (fewer characters) and more flexible (width can be set according to individual preference) than spaces, so it seems sensible to default to them unless there's a reason to use spaces.

One reason would be to align code to an arbitrary column, for example to have function arguments aligned like this:

```javascript
doSomething(a,
            b);
```

...but if the next suggestion is also followed, that doesn't come up:

All multi-line constructions can follow the same simple rule for indentation
---

If something has opening and closing delimiters and becomes too long to put on one line, split it up like this:

- The opening delimiter stays where it is (where it would be for a single-line construction).
- The body starts on the next line, indented by one.
- The closing delimiter goes on the next line after the body, at the same indentation as the opening line, i.e. one less than the body.
- Subsequent code carries on from the closing delimiter, in some cases with an extra newline to give multi-line phrases some breathing room.

This works for functions, classes, loops, objects, arrays, function arguments (both calls and definitions), strings, and arbitrary expressions, for example big conditions joined by logical operators.  For these expressions, if not already in the brackets of an `if` statement or other construct, use a pair of brackets as the opening and closing delimeters and start each line after the first with the operator that connects it to the previous line.

This makes code look consistent and avoids having to adjust indentation levels when things like function names change, as would be needed if the `doSomething` function from the previous example were renamed.  The main practical disadvantage is that expressions take up slightly more vertical space when the closing delimiter is always on its own line.

### Examples:

```javascript
function fn(args) {
	doSomething();
	doSomething();
}

class A {
	constructor() {
		this.prop = 123;
	}
}

let obj = {
	a: 1,
	b: 2,
};

let array = [
	123,
	456,
];

let cond = (
	something
	&& somethingElse
	|| somethingElse
);

let cond = (
	something
	? somethingElse
	: somethingElse
);

function bigArgs(
	arg1,
	arg2,
) {
	doSomething();
	doSomething();
}

bigCall(
	123,
	456,
);

let str = `
	lorem ipsum
	dolor sit
	amet
`;

for (let i = 0; i < n; i++) {
	doSomething();
}
```