startx 0.0.1

package/configs/eslint-config/src/rules/no-internal-package-import.ts

@@ -0,0 +1,40 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoInternalPackageImportRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: "no-internal-package-import",
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow imports from internal package paths (e.g. `/pkg/src/...`).',
+		},
+		messages: {
+			noInternalPackageImport:
+				'Import from "{{ packageRoot }}", not from the internal `/src/` path.',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		const INTERNAL_IMPORT_REGEX = /^(?<packageRoot>\/[^/]+)\/src\//;
+
+		return {
+			ImportDeclaration(node) {
+				if (typeof node.source.type !== 'string') return;
+
+				const match = node.source.value.match(INTERNAL_IMPORT_REGEX);
+
+				if (!match?.groups) return;
+
+				const { packageRoot } = match.groups;
+
+				context.report({
+					node: node.source,
+					messageId: 'noInternalPackageImport',
+					fix: (fixer) => fixer.replaceText(node.source, `"${packageRoot}"`),
+					data: { packageRoot },
+				});
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-interpolation-in-regular-string.ts

@@ -0,0 +1,32 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoInterpolationInRegularStringRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-interpolation-in-regular-string',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'String interpolation `${...}` requires backticks, not single or double quotes.',
+		},
+		messages: {
+			useBackticks: 'Use backticks to interpolate',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			Literal(node) {
+				if (typeof node.value !== 'string') return;
+
+				if (/\$\{/.test(node.value)) {
+					context.report({
+						messageId: 'useBackticks',
+						node,
+						fix: (fixer) => fixer.replaceText(node, `\`${node.value}\``),
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-json-parse-json-stringify.test.ts

@@ -0,0 +1,34 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { NoJsonParseJsonStringifyRule } from './no-json-parse-json-stringify.js';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-json-parse-json-stringify', NoJsonParseJsonStringifyRule, {
+	valid: [
+		{
+			code: 'deepCopy(foo)',
+		},
+	],
+	invalid: [
+		{
+			code: 'JSON.parse(JSON.stringify(foo))',
+			errors: [{ messageId: 'noJsonParseJsonStringify' }],
+			output: 'deepCopy(foo)',
+		},
+		{
+			code: 'JSON.parse(JSON.stringify(foo.bar))',
+			errors: [{ messageId: 'noJsonParseJsonStringify' }],
+			output: 'deepCopy(foo.bar)',
+		},
+		{
+			code: 'JSON.parse(JSON.stringify(foo.bar.baz))',
+			errors: [{ messageId: 'noJsonParseJsonStringify' }],
+			output: 'deepCopy(foo.bar.baz)',
+		},
+		{
+			code: 'JSON.parse(JSON.stringify(foo.bar[baz]))',
+			errors: [{ messageId: 'noJsonParseJsonStringify' }],
+			output: 'deepCopy(foo.bar[baz])',
+		},
+	],
+});

package/configs/eslint-config/src/rules/no-json-parse-json-stringify.ts

@@ -0,0 +1,49 @@
+import { isJsonParseCall, isJsonStringifyCall } from '../utils/json.js';
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+export const NoJsonParseJsonStringifyRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-json-parse-json-stringify',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Calls to `JSON.parse(JSON.stringify(arg))` must be replaced with `deepCopy(arg)` from `workflow`.',
+		},
+		schema: [],
+		messages: {
+			noJsonParseJsonStringify: 'Replace with `deepCopy({{ argText }})`',
+		},
+		fixable: 'code',
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CallExpression(node) {
+				if (isJsonParseCall(node) && isJsonStringifyCall(node)) {
+					const [callExpression] = node.arguments;
+
+					if (callExpression.type !== TSESTree.AST_NODE_TYPES.CallExpression) {
+						return;
+					}
+
+					const { arguments: args } = callExpression;
+
+					if (!Array.isArray(args) || args.length !== 1) return;
+
+					const [arg] = args;
+
+					if (!arg) return;
+
+					const argText = context.sourceCode.getText(arg);
+
+					context.report({
+						messageId: 'noJsonParseJsonStringify',
+						node,
+						data: { argText },
+						fix: (fixer) => fixer.replaceText(node, `deepCopy(${argText})`),
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-plain-errors.ts

@@ -0,0 +1,50 @@
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+export const NoPlainErrorsRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-plain-errors',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Only `ApplicationError` (from the `workflow` package) or its child classes must be thrown. This ensures the error will be normalized when reported to Sentry, if applicable.',
+		},
+		messages: {
+			useApplicationError:
+				'Throw an `ApplicationError` (from the `workflow` package) or its child classes.',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ThrowStatement(node) {
+				if (!node.argument) return;
+
+				const isNewError =
+					node.argument.type === TSESTree.AST_NODE_TYPES.NewExpression &&
+					node.argument.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+					node.argument.callee.name === 'Error';
+
+				const isNewlessError =
+					node.argument.type === TSESTree.AST_NODE_TYPES.CallExpression &&
+					node.argument.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+					node.argument.callee.name === 'Error';
+
+				if (isNewError || isNewlessError) {
+					return context.report({
+						messageId: 'useApplicationError',
+						node,
+						fix: (fixer) =>
+							fixer.replaceText(
+								node,
+								`throw new ApplicationError(${(node.argument as TSESTree.CallExpression).arguments
+									.map((arg) => context.sourceCode.getText(arg))
+									.join(', ')})`,
+							),
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-skipped-tests.ts

@@ -0,0 +1,61 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+export const NoSkippedTestsRule = ESLintUtils.RuleCreator.withoutDocs({
+  name: "no-skipped-tests",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Tests must not be skipped.",
+    },
+    messages: {
+      removeSkip: "Remove `.skip()` call",
+      removeOnly: "Remove `.only()` call",
+      removeXPrefix: "Remove `x` prefix",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const TESTING_FUNCTIONS = new Set(["test", "it", "describe"]);
+    const SKIPPING_METHODS = new Set(["skip", "only"]);
+    const PREFIXED_TESTING_FUNCTIONS = new Set(["xtest", "xit", "xdescribe"]);
+    const toMessageId = (s: string) =>
+      `remove${s.charAt(0).toUpperCase()}${s.slice(1)}` as
+        | "removeSkip"
+        | "removeOnly"
+        | "removeXPrefix";
+
+    return {
+      MemberExpression(node) {
+        if (
+          node.object.type === "Identifier" &&
+          TESTING_FUNCTIONS.has(node.object.name) &&
+          node.property.type === "Identifier" &&
+          SKIPPING_METHODS.has(node.property.name)
+        ) {
+          context.report({
+            messageId: toMessageId(node.property.name),
+            node,
+            fix: (fixer) => {
+              const [start, end] = node.property.range;
+              return fixer.removeRange([start - ".".length, end]);
+            },
+          });
+        }
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type === "Identifier" &&
+          PREFIXED_TESTING_FUNCTIONS.has(node.callee.name)
+        ) {
+          context.report({
+            messageId: "removeXPrefix",
+            node,
+            fix: (fixer) => fixer.replaceText(node.callee, "test"),
+          });
+        }
+      },
+    };
+  },
+});

package/configs/eslint-config/src/rules/no-top-level-relative-imports-in-backend-module.ts

@@ -0,0 +1,27 @@
+import { ESLintUtils, type TSESTree } from '@typescript-eslint/utils';
+
+export const NoTopLevelRelativeImportsInBackendModuleRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-top-level-relative-imports-in-backend-module',
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'Relative imports in `.module.ts` files must be placed inside the `init` method. This ensures that module imports are loaded only when the module is used.',
+		},
+		messages: {
+			placeInsideInit:
+				"Place this relative import inside the `init` method, using `await import('./path')` syntax.",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			'Program > ImportDeclaration'(node: TSESTree.ImportDeclaration) {
+				if (node.source.value.startsWith('.')) {
+					context.report({ node, messageId: 'placeInsideInit' });
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-type-unsafe-event-emitter.ts

@@ -0,0 +1,33 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoTypeUnsafeEventEmitterRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-type-unsafe-event-emitter',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow extending from `EventEmitter`, which is not type-safe.',
+		},
+		messages: {
+			noExtendsEventEmitter: 'Extend from the type-safe `TypedEmitter` class instead.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (
+					node.superClass &&
+					node.superClass.type === 'Identifier' &&
+					node.superClass.name === 'EventEmitter' &&
+					node.id?.name !== 'TypedEmitter'
+				) {
+					context.report({
+						node: node.superClass,
+						messageId: 'noExtendsEventEmitter',
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-uncaught-json-parse.test.ts

@@ -0,0 +1,21 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import { NoUncaughtJsonParseRule } from "./no-uncaught-json-parse.js";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-uncaught-json-parse", NoUncaughtJsonParseRule, {
+  valid: [
+    {
+      code: "try { JSON.parse(foo) } catch (e) {}",
+    },
+    {
+      code: "JSON.parse(JSON.stringify(foo))",
+    },
+  ],
+  invalid: [
+    {
+      code: "JSON.parse(foo)",
+      errors: [{ messageId: "noUncaughtJsonParse" }],
+    },
+  ],
+});

package/configs/eslint-config/src/rules/no-uncaught-json-parse.ts

@@ -0,0 +1,45 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { isJsonParseCall, isJsonStringifyCall } from '../utils/json.js';
+
+export const NoUncaughtJsonParseRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-uncaught-json-parse',
+	meta: {
+		type: 'problem',
+		hasSuggestions: true,
+		docs: {
+			description:
+				'Calls to `JSON.parse()` must be replaced with `jsonParse()` from `workflow` or surrounded with a try/catch block.',
+		},
+		schema: [],
+		messages: {
+			noUncaughtJsonParse:
+				'Use `jsonParse()` from `workflow` or surround the `JSON.parse()` call with a try/catch block.',
+		},
+	},
+	defaultOptions: [],
+	create({ report, sourceCode }) {
+		return {
+			CallExpression(node) {
+				if (!isJsonParseCall(node)) {
+					return;
+				}
+
+				if (isJsonStringifyCall(node)) {
+					return;
+				}
+
+				if (
+					sourceCode.getAncestors(node).find((node) => node.type === 'TryStatement') !== undefined
+				) {
+					return;
+				}
+
+				// Found a JSON.parse() call not wrapped into a try/catch, so report it
+				report({
+					messageId: 'noUncaughtJsonParse',
+					node,
+				});
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-untyped-config-class-field.ts

@@ -0,0 +1,26 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUntypedConfigClassFieldRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: "no-untyped-config-class-field",
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce explicit typing of config class fields',
+		},
+		messages: {
+			noUntypedConfigClassField:
+				'Class field must have an explicit type annotation, e.g. `field: type = value`.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			PropertyDefinition(node) {
+				if (!node.typeAnnotation) {
+					context.report({ node: node.key, messageId: 'noUntypedConfigClassField' });
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-unused-param-catch-clause.ts

@@ -0,0 +1,33 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUnusedParamInCatchClauseRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: "no-unused-param-catch-clause",
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Unused param in catch clause must be omitted.',
+		},
+		messages: {
+			removeUnusedParam: 'Remove unused param in catch clause',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (node.param?.type === 'Identifier' && node.param.name.startsWith('_')) {
+					const start = node.range[0] + 'catch '.length;
+					const end = node.param.range[1] + '()'.length;
+
+					context.report({
+						messageId: 'removeUnusedParam',
+						node,
+						fix: (fixer) => fixer.removeRange([start, end]),
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-useless-catch-throw.test.ts

@@ -0,0 +1,34 @@
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import { NoUselessCatchThrowRule } from "./no-useless-catch-throw.js";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-useless-catch-throw", NoUselessCatchThrowRule, {
+  valid: [
+    {
+      code: "try { foo(); } catch (e) { console.error(e); }",
+    },
+    {
+      code: 'try { foo(); } catch (e) { throw new Error("Custom error"); }',
+    },
+  ],
+  invalid: [
+    {
+      code: `
+try {
+	// Some comment
+	if (foo) {
+		bar();
+	}
+} catch (e) {
+	throw e;
+}`,
+      errors: [{ messageId: "noUselessCatchThrow" }],
+      output: `
+// Some comment
+if (foo) {
+	bar();
+}`,
+    },
+  ],
+});

package/configs/eslint-config/src/rules/no-useless-catch-throw.ts

@@ -0,0 +1,47 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUselessCatchThrowRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-useless-catch-throw',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow `try-catch` blocks where the `catch` only contains a `throw error`.',
+		},
+		messages: {
+			noUselessCatchThrow: 'Remove useless `catch` block.',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (
+					node.body.body.length === 1 &&
+					node.body.body[0].type === 'ThrowStatement' &&
+					node.body.body[0].argument.type === 'Identifier' &&
+					node.param?.type === 'Identifier' &&
+					node.body.body[0].argument.name === node.param.name
+				) {
+					context.report({
+						node,
+						messageId: 'noUselessCatchThrow',
+						fix(fixer) {
+							const tryStatement = node.parent;
+							const tryBlock = tryStatement.block;
+							const sourceCode = context.sourceCode;
+							const tryBlockText = sourceCode.getText(tryBlock);
+							const tryBlockTextWithoutBraces = tryBlockText.slice(1, -1).trim();
+							const indentedTryBlockText = tryBlockTextWithoutBraces
+								.split('\n')
+								.map((line) => line.replace(/\t/, ''))
+								.join('\n');
+							return fixer.replaceText(tryStatement, indentedTryBlockText);
+						},
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/utils/json.ts

@@ -0,0 +1,21 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+
+export const isJsonParseCall = (node: TSESTree.CallExpression) =>
+	node.callee.type === 'MemberExpression' &&
+	node.callee.object.type === 'Identifier' &&
+	node.callee.object.name === 'JSON' &&
+	node.callee.property.type === 'Identifier' &&
+	node.callee.property.name === 'parse';
+
+export const isJsonStringifyCall = (node: TSESTree.CallExpression) => {
+	const parseArg = node.arguments?.[0];
+	return (
+		parseArg !== undefined &&
+		parseArg.type === 'CallExpression' &&
+		parseArg.callee.type === 'MemberExpression' &&
+		parseArg.callee.object.type === 'Identifier' &&
+		parseArg.callee.object.name === 'JSON' &&
+		parseArg.callee.property.type === 'Identifier' &&
+		parseArg.callee.property.name === 'stringify'
+	);
+};

package/configs/eslint-config/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "typescript-config/tsconfig.node.json",
+	"compilerOptions": {
+		"baseUrl": "./src"
+	},
+
+	"include": ["src/**/*.ts", "vitest.config.ts", "plugins.d.ts"]
+}

package/configs/eslint-config/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsdown";
+import { baseConfig } from "tsdown-config";
+
+export default defineConfig({
+  ...baseConfig,
+	unbundle: false,
+	clean:false,
+  entry: [
+    "./src/**/*.ts",
+  ],
+});

package/configs/eslint-config/vitest.config.ts

@@ -0,0 +1,3 @@
+import vitestConfig from "vitest-config/node";
+
+export default vitestConfig;

package/configs/tsdown-config/package.json

@@ -0,0 +1,14 @@
+{
+	"name": "tsdown-config",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"exports": "./src/config/tsdown.base.ts",
+	"scripts": {
+		"clean": "rimraf dist",
+		"deep:clean": "rimraf node_modules dist"
+	}
+}

package/configs/tsdown-config/src/config/tsdown.base.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsdown";
+export const baseConfig = defineConfig({
+  entry: ["./src/index.ts"],
+  format: ["esm"],
+  clean: true,
+  target: "es2022",
+  sourcemap: false,
+  minify: true,
+  treeshake: true,
+  shims: true,
+	unbundle: false,
+  external: [/^@unrs\//],
+});

package/configs/typescript-config/package.json

@@ -0,0 +1,10 @@
+{
+	"name": "typescript-config",
+	"version": "0.0.0",
+	"private": true,
+	"files": [
+		"tsconfig.common.json",
+		"tsconfig.frontend.json",
+		"tsconfig.node.json"
+	]
+}

package/configs/typescript-config/tsconfig.common.json

@@ -0,0 +1,32 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"useDefineForClassFields": true,
+		"module": "ESNext",
+		"lib": ["ES2022"],
+		"skipLibCheck": true,
+
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"noEmit": true,
+
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"useUnknownInCatchVariables": true,
+		"strictNullChecks": true,
+		"noImplicitAny": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"forceConsistentCasingInFileNames": true,
+		"removeComments": true,
+
+		"tsBuildInfoFile": "dist/typecheck.tsbuildinfo"
+	},
+	"exclude": ["node_modules", "dist"]
+}

package/configs/typescript-config/tsconfig.frontend.json

@@ -0,0 +1,14 @@
+{
+	"extends": "./tsconfig.common.json",
+	"compilerOptions": {
+		"target": "esnext",
+		"module": "esnext",
+		"moduleResolution": "bundler",
+		"importHelpers": true,
+		"allowJs": true,
+		"incremental": false,
+		"jsx": "react-jsx",
+		"allowSyntheticDefaultImports": true,
+		"lib": ["esnext", "dom", "dom.iterable", "scripthost"]
+	}
+}