get-symbols 0.0.1

package/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = tab
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+end_of_line = lf

package/.prettierrc.json

@@ -0,0 +1,17 @@
+{
+	"plugins": [
+		"prettier-plugin-brace-style",
+		"prettier-plugin-space-before-function-paren",
+		"prettier-plugin-merge"
+	],
+	"braceStyle": "stroustrup",
+	"arrowParens": "avoid",
+	"bracketSpacing": true,
+	"endOfLine": "auto",
+	"semi": true,
+	"singleQuote": false,
+	"tabWidth": 4,
+	"useTabs": true,
+	"trailingComma": "all",
+	"printWidth": 100
+}

package/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "prettier.enable": true,
+  "debug.enableStatusBarColor": false
+}

package/README.md

@@ -0,0 +1,52 @@
+# Get symbols
+
+Hassle-free JS symbols. Like, lots of them.
+
+get-symbols lets you easily create new symbols through object destructuring:
+
+```js
+import symbols from "get-symbols";
+
+let { foo, bar, baz } = symbols.new;
+// console.log(foo, bar, baz); // Symbol(foo) Symbol(bar) Symbol(baz)
+```
+
+`symbols.new` will always create new symbols, even for the same name:
+
+```js
+foo === symbols.new.foo; // false
+```
+
+If you'd rather reuse symbols with the same name, you can use `symbols.known`:
+
+```js
+import symbols from "symbols";
+
+let { foo, bar, baz } = symbols.known;
+// foo, bar, baz are new symbols
+// with descriptions "foo", "bar", "baz"
+
+foo === symbols.known.foo; // true
+```
+
+You can import `KNOWN_SYMBOLS` to get the symbols registry:
+
+```js
+import { KNOWN_SYMBOLS } from "symbols";
+
+console.log(KNOWN_SYMBOLS); // { foo: Symbol(foo), bar: Symbol(bar), baz: Symbol(baz) }
+```
+
+## Custom registries
+
+You can create your own symbols registry by calling `symbols.registry()` that behaves like `symbols.known`:
+
+```js
+import symbols from "symbols";
+
+let registry = symbols.registry();
+
+let { foo, bar, baz } = registry;
+
+console.log(foo, bar, baz); // Symbol(foo) Symbol(bar) Symbol(baz)
+```

package/index.js

@@ -0,0 +1,43 @@
+export const KNOWN_SYMBOLS = {};
+
+export const newSymbols = new Proxy(
+	{},
+	{
+		get (target, prop) {
+			if (typeof prop === "string") {
+				return Symbol(prop);
+			}
+
+			return target[prop];
+		},
+	},
+);
+
+export function registry (knownSymbols = {}) {
+	return new Proxy(
+		{},
+		{
+			get (target, prop) {
+				if (typeof prop === "string") {
+					if (knownSymbols[prop]) {
+						return knownSymbols[prop];
+					}
+
+					let ret = Symbol(prop);
+					knownSymbols[prop] = ret;
+					return ret;
+				}
+
+				return target[prop];
+			},
+		},
+	);
+}
+
+export const known = registry(KNOWN_SYMBOLS);
+
+export default {
+	new: newSymbols,
+	known,
+	registry,
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "get-symbols",
+	"version": "0.0.1",
+	"description": "Description",
+	"keywords": [],
+	"homepage": "https://github.com/leaverou/get-symbols/#readme",
+	"bugs": {
+		"url": "https://github.com/leaverou/get-symbols/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/leaverou/get-symbols.git"
+	},
+	"license": "MIT",
+	"author": "Lea Verou",
+	"type": "module",
+	"main": "src/index.js",
+	"exports": {
+		".": "./index.js"
+	},
+	"scripts": {
+		"release": "npm login && release-it",
+		"test": "npx htest test/index.js"
+	},
+	"devDependencies": {
+		"htest.dev": "^0.0.23",
+		"prettier": "~3.5.3",
+		"prettier-plugin-brace-style": "latest",
+		"prettier-plugin-merge": "latest",
+		"prettier-plugin-space-before-function-paren": "latest",
+		"release-it": "latest"
+	}
+}

package/test/index.js

@@ -0,0 +1,102 @@
+import { newSymbols, known, registry, KNOWN_SYMBOLS } from "../index.js";
+
+export default {
+	name: "get-symbols",
+	tests: [
+		{
+			name: "newSymbols",
+			tests: [
+				{
+					name: "Creates a Symbol with correct description",
+					run: arg => newSymbols[arg].description,
+					tests: [
+						{ arg: "foo", expect: "foo" },
+						{ arg: "myName", expect: "myName" },
+					],
+				},
+				{
+					name: "Always creates a new Symbol",
+					run: () => newSymbols.same === newSymbols.same,
+					expect: false,
+				},
+			],
+		},
+		{
+			name: "known",
+			tests: [
+				{
+					name: "Creates a Symbol with correct description",
+					run: arg => known[arg].description,
+					tests: [
+						{ arg: "testKnown", expect: "testKnown" },
+						{ arg: "testDesc", expect: "testDesc" },
+					],
+				},
+				{
+					name: "Returns the same Symbol on repeated access",
+					run () {
+						let first = known.memoTest;
+						let second = known.memoTest;
+						return first === second;
+					},
+					expect: true,
+				},
+				{
+					name: "Stores symbols in KNOWN_SYMBOLS",
+					run () {
+						let sym = known.storedTest;
+						return KNOWN_SYMBOLS.storedTest === sym;
+					},
+					expect: true,
+				},
+			],
+		},
+		{
+			name: "registry()",
+			tests: [
+				{
+					name: "Creates a registry that produces Symbols",
+					run: () => typeof registry().foo,
+					expect: "symbol",
+				},
+				{
+					name: "Memoizes within the registry",
+					run () {
+						let r = registry();
+						return r.x === r.x;
+					},
+					expect: true,
+				},
+				{
+					name: "Stores symbols in the provided object",
+					run () {
+						let store = {};
+						let r = registry(store);
+						let sym = r.myKey;
+						return store.myKey === sym;
+					},
+					expect: true,
+				},
+				{
+					name: "Registries are isolated from each other",
+					run () {
+						let r1 = registry();
+						let r2 = registry();
+						return r1.foo === r2.foo;
+					},
+					expect: false,
+				},
+				{
+					name: "Uses pre-existing symbols from the provided object",
+					run () {
+						let existing = Symbol("pre");
+						let store = { pre: existing };
+						let r = registry(store);
+						return r.pre === existing;
+					},
+					expect: true,
+				},
+			],
+		},
+	],
+};