@jskit-ai/config-eslint 0.1.241 → 0.1.243

package/README.md

@@ -0,0 +1,135 @@
+# @jskit-ai/config-eslint
+
+Shared flat ESLint presets for JSKIT projects.
+
+```js
+// eslint.config.mjs
+import {
+  baseConfig,
+  clientFeaturesConfig,
+  formatterConfig,
+  nodeConfig,
+  sizeLimitsConfig,
+  typedFeaturesConfig,
+  vueConfig,
+  webConfig
+} from "@jskit-ai/config-eslint/server";
+
+const SERVER_SOURCES = ["packages/*/src/server/**", "packages/*/src/shared/**", "server/**", "server.js"];
+const CLIENT_SOURCES = ["packages/*/src/client/**", "src/**"];
+const HAND_WRITTEN_SOURCES = ["packages/*/src/**", "src/**", "config/**", "server/**", "server.js", "bin/**"];
+
+export default [
+  ...baseConfig,
+  ...typedFeaturesConfig(SERVER_SOURCES),
+  ...sizeLimitsConfig(HAND_WRITTEN_SOURCES),
+  ...vueConfig,
+  ...clientFeaturesConfig(CLIENT_SOURCES),
+  ...webConfig,
+  ...nodeConfig,
+  ...formatterConfig([...SERVER_SOURCES, "config/**", "bin/**"])
+];
+```
+
+- `baseConfig`: ESLint's recommended rules, JSKIT's import policy and, as
+  warnings on `**/src/server/**`, the typed-features rules.
+- `typedFeaturesConfig(globs)`: the typed-features rules and the size limits,
+  as errors, for the server and shared code the globs select.
+- `clientFeaturesConfig(globs)`: the client rules, as errors, for the client
+  code the globs select, Vue components included; list it after `vueConfig`.
+- `sizeLimitsConfig(globs)`: files under 750 lines and functions under 600, as
+  errors, for every hand-written file the globs select, client code and Vue
+  components included.
+- `formatterConfig(globs)`: the formatter.
+- `nodeConfig`, `webConfig`: Node and browser globals.
+- `vueConfig`: `eslint-plugin-vue`'s recommended rules.
+
+## Formatter
+
+`formatterConfig(globs)` is the one formatter config of a JSKIT application, as
+errors, for the source files the globs select (tests are not formatted):
+
+```js
+// eslint.config.mjs
+import { baseConfig, formatterConfig, typedFeaturesConfig } from "@jskit-ai/config-eslint/server";
+
+const SERVER_SOURCES = ["packages/*/src/server/**", "packages/*/src/shared/**", "server/**", "server.js"];
+
+export default [
+  ...baseConfig,
+  ...typedFeaturesConfig(SERVER_SOURCES),
+  // Published upgrade scripts never change, so the formatter leaves them alone.
+  ...formatterConfig(SERVER_SOURCES, { ignores: ["packages/core/src/server/upgrades/**"] })
+];
+```
+
+- Width 140 for code, comments and JSDoc prose. Strings, template literals,
+  regular expressions, URLs, `readable-check: allow` comments, ESLint
+  directives and JSDoc type tags may run past it, so long prose stays inline.
+- Semicolons, double quotes (template literals allowed), no trailing commas,
+  no space before a named function's parentheses, no repeated or trailing
+  spaces.
+- A one-line body without braces stays beside its `if` (`if (!x) return null;`);
+  an `if`/`else` chain braces all its bodies or none, and a line holds at most
+  two statements.
+- An object whose properties span lines puts each property on its own line,
+  with its braces on their own lines; a call whose arguments span lines breaks
+  after `(` and before `)`.
+- A braced block spans lines (`1tbs`: `} else {` on the closing brace's line),
+  and code is indented by two spaces, `case` inside `switch` by one level and a
+  ternary's object, array or function branch past its `?`.
+
+`eslint --fix` fixes all of these except the width and the statements per line,
+and its output passes them: a block it braces or an argument list it breaks is
+re-indented in the same run.
+
+## Typed features
+
+The `jskit` plugin checks the rules of the
+[typed features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features),
+the one place JSKIT explains how server code is written. Its
+[lint rules table](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features#lint-rules)
+lists what each rule reports, every finding ends with a link to the section
+that explains it, and its
+[exceptions](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features#exceptions)
+give the `readable-check: allow` comment and its reason prefixes.
+
+`baseConfig` reports the rules as warnings, so adopting a new version does not
+fail a build. `typedFeaturesConfig(globs)` makes them errors for the globs you
+list; an existing application adds each package as it converts it. The rules
+cover every module a capability value is built from, so list a package's
+shared modules too (`packages/billing/src/shared/**`). Test files and `test`,
+`tests`, `client`, `components` and `pages` directories are not checked.
+
+## Client features
+
+`clientFeaturesConfig(globs, severity = "error")` holds composables, Vue
+components, client factories and client providers to the
+[client features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/client-features):
+the typed-features rules that read client code, with `use*` composables
+counted as factories and component templates read for probes and optional
+calls, plus `typed-inject`, `collaborator-props`, `fixed-result-shape`,
+`no-frozen-vue-state`, `released-listeners`, `no-module-state` and
+`eslint-plugin-vue`'s prop and emit rules. The server's action and error rules
+do not apply, a composable is never held to `Object.freeze`, and
+`no-duplicate-helper` compares a client helper with the whole package. Nothing
+changes for client code until a glob selects it, so an existing application
+lists each client tree as it converts it. In a template, one
+`<!-- readable-check: allow <rule> - <reason> -->` above an element excuses
+that element's bindings.
+
+`sizeLimitsConfig(globs, { ignores })` holds the rest of the hand-written code
+to the size limits; tests are not checked, and `ignores` leaves generated
+output alone. A generated or static data module is exempt through its first
+line, `/* eslint-disable max-lines -- data: <how it is produced> */`.
+
+`one-line-action` leaves CRUD custom actions' `execute({ input, service, … })`
+alone, also when it takes only part of that object (`({ service, context })`):
+that is the CRUD declaration's own contract. `no-duplicate-helper` and
+`named-repeated-type` compare a file with the rest of its package. Both treat a
+pattern's example application (an `example` directory beside a `PATTERN.md`)
+as a package of its own, skip `templates` and `patterns` directories inside a
+package, and leave the agent skill bundle's generated copies under
+`skills/jskit/references/patterns` to their sources. `app-error-code` follows
+the error classes a module declares, and compares codes and sentences within
+one module.

package/base.js

@@ -1,4 +1,5 @@
 import js from "@eslint/js";
+import { typedFeaturesConfig } from "./typedFeatures.js";
 
 const SOURCE_FILES = "**/*.{js,mjs,cjs,vue}";
 
@@ -43,7 +44,10 @@ const baseConfig = Object.freeze([
         }
       ]
     }
-  }
+  },
+  // Server code is reported against the typed-features rules; an application
+  // makes them errors with typedFeaturesConfig as it converts each package.
+  ...typedFeaturesConfig(["**/src/server/**"], "warn")
 ]);
 
 export { baseConfig };

package/clientFeatures.js

@@ -0,0 +1,87 @@
+import vuePlugin from "eslint-plugin-vue";
+import vueParser from "vue-eslint-parser";
+import { jskitPlugin } from "./plugin/index.js";
+import { sizeLimitRules } from "./typedFeatures.js";
+
+const CLIENT_SOURCE_FILES = "**/*.{js,mjs,vue}";
+const COMPONENT_FILES = "**/*.vue";
+const TEST_FILES = Object.freeze([
+  "**/{test,tests}/**",
+  "**/*.{test,spec,vitest}.*"
+]);
+
+// The typed-features rules that read client code, and the client-only rules, at one severity: collaborators of
+// composables, client factories and providers are typed where received and required, never probed, in scripts and
+// templates; injected values take an exported key, a type and no empty default; props a component calls are required
+// and typed by their contract; results keep the shape they are built with and hold Vue state unfrozen; whatever client
+// code starts it releases; no module-level mutable state; one copy of each helper per package; files under 750 lines
+// and functions under 600. The server's action and error rules have no client counterpart, and a composable's result is
+// never held to Object.freeze.
+function clientFeaturesRules(severity) {
+  return Object.freeze({
+    "jskit/typed-dependencies": severity,
+    "jskit/required-collaborators": severity,
+    "jskit/no-slot-setter": severity,
+    "jskit/no-module-registry": severity,
+    "jskit/no-duplicate-helper": severity,
+    "jskit/allow-comment-form": severity,
+    "jskit/jsdoc-description-inside": severity,
+    "jskit/no-dual-shape": severity,
+    "jskit/named-repeated-type": severity,
+    "jskit/no-factory-spread": severity,
+    "jskit/frozen-factory-result": severity,
+    "jskit/no-optional-after-default": severity,
+    "jskit/one-property-per-line": severity,
+    "jskit/no-env-default": severity,
+    "jskit/no-test-only-export": severity,
+    "jskit/typed-inject": severity,
+    "jskit/collaborator-props": severity,
+    "jskit/fixed-result-shape": severity,
+    "jskit/released-listeners": severity,
+    "jskit/no-module-state": severity,
+    "jskit/no-frozen-vue-state": severity,
+    ...sizeLimitRules(severity)
+  });
+}
+
+// Every prop has a type and is required or defaulted (never both), and every emitted event is declared.
+function componentRules(severity) {
+  return Object.freeze({
+    "vue/require-prop-types": severity,
+    "vue/require-default-prop": severity,
+    "vue/require-valid-default-prop": severity,
+    "vue/no-required-prop-with-default": severity,
+    "vue/require-explicit-emits": severity
+  });
+}
+
+/**
+ * The typed-features rules for the client source files the globs select (modules and Vue components; tests excluded),
+ * as errors unless another severity is given. An application lists each client tree as it converts it, so the rules
+ * it already follows stay followed; nothing else changes until it does.
+ * @param {string[]} files
+ * @param {"error" | "warn" | "off"} [severity]
+ */
+function clientFeaturesConfig(files, severity = "error") {
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new TypeError("clientFeaturesConfig requires a list of file globs.");
+  }
+  return Object.freeze([
+    Object.freeze({
+      files: files.map((pattern) => [pattern, CLIENT_SOURCE_FILES]),
+      ignores: TEST_FILES,
+      plugins: { jskit: jskitPlugin },
+      settings: { jskit: { client: true } },
+      rules: clientFeaturesRules(severity)
+    }),
+    Object.freeze({
+      files: files.map((pattern) => [pattern, COMPONENT_FILES]),
+      ignores: TEST_FILES,
+      plugins: { vue: vuePlugin },
+      languageOptions: { parser: vueParser },
+      rules: componentRules(severity)
+    })
+  ]);
+}
+
+export { clientFeaturesConfig };

package/formatter.js

@@ -0,0 +1,60 @@
+const SOURCE_FILES = "**/*.{js,mjs}";
+// Lines that may run past the width: allow comments, ESLint directives and JSDoc type tags, whose text cannot wrap.
+const LONG_TEXT_PATTERN = "readable-check: allow|eslint-disable|@typedef|@type \\{|@param \\{|@property \\{|@returns \\{";
+const NOT_FORMATTED = Object.freeze([
+  "**/{test,tests}/**",
+  "**/*.test.*"
+]);
+
+const FORMATTER_RULES = Object.freeze({
+  // Code, comments and JSDoc prose wrap at 140 characters; long prose stays inline in strings and templates.
+  "max-len": ["error", {
+    code: 140,
+    ignoreUrls: true,
+    ignoreStrings: true,
+    ignoreTemplateLiterals: true,
+    ignoreRegExpLiterals: true,
+    ignorePattern: LONG_TEXT_PATTERN
+  }],
+  semi: ["error", "always"],
+  quotes: ["error", "double", { avoidEscape: true, allowTemplateLiterals: true }],
+  "comma-dangle": ["error", "never"],
+  "space-before-function-paren": ["error", { anonymous: "ignore", named: "never", asyncArrow: "ignore" }],
+  // One layout: a one-line `if (x) return y;`, or braces; one property per line once an object spans lines.
+  curly: ["error", "multi-line", "consistent"],
+  "nonblock-statement-body-position": ["error", "beside"],
+  "object-curly-newline": ["error", { multiline: true, consistent: true }],
+  "object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+  "function-paren-newline": ["error", "multiline-arguments"],
+  "max-statements-per-line": ["error", { max: 2 }],
+  "no-multi-spaces": "error",
+  "no-trailing-spaces": "error",
+  // A braced block spans lines, `} else {` stays on the closing brace's line, and two-space indentation re-indents
+  // what the other fixes break onto new lines. A ternary's object, array or function branch is indented past its `?`.
+  "brace-style": ["error", "1tbs"],
+  "block-spacing": ["error", "always"],
+  indent: ["error", 2, { SwitchCase: 1, offsetTernaryExpressions: true }]
+});
+
+/**
+ * The one formatter config of a JSKIT application, as errors, for the source files the globs select: width 140,
+ * semicolons, double quotes, no trailing commas, one property per line in an object that spans lines, a one-line
+ * `if` only without braces, braced blocks on their own lines and two-space indentation. Tests are not formatted.
+ * @param {string[]} files
+ * @param {{ ignores?: string[] }} [options] Files the formatter never touches, such as published scripts that must not
+ * change.
+ */
+function formatterConfig(files, { ignores = [] } = {}) {
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new TypeError("formatterConfig requires a list of file globs.");
+  }
+  return Object.freeze([
+    Object.freeze({
+      files: files.map((pattern) => [pattern, SOURCE_FILES]),
+      ignores: [...NOT_FORMATTED, ...ignores],
+      rules: FORMATTER_RULES
+    })
+  ]);
+}
+
+export { formatterConfig };

package/index.js

@@ -2,3 +2,7 @@ export { baseConfig } from "./base.js";
 export { nodeConfig } from "./node.js";
 export { webConfig } from "./web.js";
 export { vueConfig } from "./vue.js";
+export { sizeLimitsConfig, typedFeaturesConfig } from "./typedFeatures.js";
+export { clientFeaturesConfig } from "./clientFeatures.js";
+export { formatterConfig } from "./formatter.js";
+export { jskitPlugin } from "./plugin/index.js";

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@jskit-ai/config-eslint",
-  "version": "0.1.241",
+  "version": "0.1.243",
   "description": "Shared flat ESLint presets for JSKIT projects.",
   "type": "module",
   "files": [
     "src",
+    "plugin",
     "base.js",
     "index.js",
     "node.js",
     "web.js",
     "vue.js",
+    "typedFeatures.js",
+    "clientFeatures.js",
+    "formatter.js",
     "README.md"
   ],
   "scripts": {
@@ -21,6 +25,9 @@
     "./node": "./node.js",
     "./web": "./web.js",
     "./vue": "./vue.js",
+    "./typed-features": "./typedFeatures.js",
+    "./client-features": "./clientFeatures.js",
+    "./formatter": "./formatter.js",
     "./server": "./src/server/index.js",
     "./client": "./src/client/index.js"
   },

package/plugin/factoryResults.js

@@ -0,0 +1,162 @@
+import { isFreezeCall } from "./support.js";
+
+// What the factory rules share: a function's defined name, what it returns,
+// and whether an object it returns holds behaviour or only data.
+
+const CREATE_NAME = /^create[A-Z]/u;
+const FUNCTION_TYPES = new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+// Vue's calls that make reactive state. A value holding their results must stay extensible: reactive() returns a
+// frozen object unproxied, so its refs stop unwrapping, and proxyRefs() (which Vue also applies to a setup() result
+// and to defineExpose()) throws reading a ref of a frozen object.
+const VUE_STATE_CALLS = new Set([
+  "ref", "shallowRef", "computed", "reactive", "shallowReactive", "readonly", "shallowReadonly", "toRef", "toRefs",
+  "customRef", "useTemplateRef", "useModel", "defineModel"
+]);
+
+// Whether a call makes Vue reactive state.
+function isVueStateCall(node) {
+  return node?.type === "CallExpression" && node.callee.type === "Identifier" && VUE_STATE_CALLS.has(node.callee.name);
+}
+
+// Whether a function makes Vue reactive state anywhere in its body: a composable or a client runtime, whose result
+// callers may hand to reactive() or proxyRefs().
+function makesVueState(sourceCode, fn) {
+  let found = false;
+  const visit = (node) => {
+    if (found || !node || typeof node.type !== "string") {
+      return;
+    }
+    if (isVueStateCall(node)) {
+      found = true;
+      return;
+    }
+    for (const key of sourceCode.visitorKeys[node.type] || []) {
+      [node[key]].flat().forEach(visit);
+    }
+  };
+  visit(fn.body);
+  return found;
+}
+
+// The name a function is defined under: its own, its variable's, its property's
+// or the member it is assigned to.
+function definedName(fn) {
+  if (fn.id?.name) {
+    return fn.id.name;
+  }
+  const parent = fn.parent;
+  if (parent?.type === "VariableDeclarator" && parent.init === fn) {
+    return parent.id.name || "";
+  }
+  if ((parent?.type === "Property" || parent?.type === "MethodDefinition") && parent.value === fn) {
+    return parent.key?.name || parent.key?.value || "";
+  }
+  if (parent?.type === "AssignmentExpression" && parent.right === fn) {
+    return parent.left.property?.name || parent.left.name || "";
+  }
+  return "";
+}
+
+// The function a return statement returns from.
+function enclosingFunction(sourceCode, node) {
+  return sourceCode.getAncestors(node).findLast((ancestor) => FUNCTION_TYPES.has(ancestor.type)) || null;
+}
+
+// The expressions a function returns: each return statement's argument, or an
+// arrow's expression body. Used from a ReturnStatement or an arrow visitor.
+function returnedFrom(sourceCode, node) {
+  if (node.type === "ReturnStatement") {
+    const fn = enclosingFunction(sourceCode, node);
+    return fn && node.argument ? { fn, returned: node.argument } : null;
+  }
+  return node.body.type === "BlockStatement" ? null : { fn: node, returned: node.body };
+}
+
+function findVariable(scope, name) {
+  for (let current = scope; current; current = current.upper) {
+    const variable = current.set.get(name);
+    if (variable) {
+      return variable;
+    }
+  }
+  return null;
+}
+
+// The single definition of the variable an identifier reads, or null.
+function definitionOf(sourceCode, identifier) {
+  const variable = findVariable(sourceCode.getScope(identifier), identifier.name);
+  return variable?.defs.length === 1 ? variable.defs[0] : null;
+}
+
+function isInlineFunction(property) {
+  return property.type === "Property" && property.kind === "init" && (property.method || FUNCTION_TYPES.has(property.value.type));
+}
+
+// A member that refers to a function the module or factory defines.
+function refersToFunction(sourceCode, property) {
+  if (property.type !== "Property" || property.value.type !== "Identifier") {
+    return false;
+  }
+  const definition = definitionOf(sourceCode, property.value);
+  return definition?.type === "FunctionName" ||
+    (definition?.type === "Variable" && FUNCTION_TYPES.has(definition.node.init?.type));
+}
+
+// An object holds behaviour when a member is a function, an accessor or a
+// reference to a function; otherwise it is data.
+function holdsBehaviour(sourceCode, object) {
+  return object.properties.some((property) => isInlineFunction(property) ||
+    (property.type === "Property" && property.kind !== "init") || refersToFunction(sourceCode, property));
+}
+
+// The function a factory name refers to in this module, or null.
+function localFunction(sourceCode, identifier) {
+  const definition = definitionOf(sourceCode, identifier);
+  if (definition?.type === "FunctionName") {
+    return definition.node;
+  }
+  const init = definition?.type === "Variable" ? definition.node.init : null;
+  return FUNCTION_TYPES.has(init?.type) ? init : null;
+}
+
+// A module function that returns only data: every value it returns is an
+// object literal, frozen or not, without behaviour.
+function returnsOnlyData(sourceCode, fn) {
+  const returned = [];
+  if (fn.body.type !== "BlockStatement") {
+    returned.push(fn.body);
+  } else {
+    const visit = (node) => {
+      if (!node || typeof node.type !== "string" || (node !== fn && FUNCTION_TYPES.has(node.type))) {
+        return;
+      }
+      if (node.type === "ReturnStatement") {
+        returned.push(node.argument);
+      }
+      for (const key of sourceCode.visitorKeys[node.type] || []) {
+        [node[key]].flat().forEach(visit);
+      }
+    };
+    visit(fn.body);
+  }
+  return returned.length > 0 && returned.every((value) => {
+    const object = isFreezeCall(value) ? value.arguments[0] : value;
+    return object?.type === "ObjectExpression" && !holdsBehaviour(sourceCode, object);
+  });
+}
+
+export {
+  CREATE_NAME,
+  FUNCTION_TYPES,
+  VUE_STATE_CALLS,
+  definedName,
+  definitionOf,
+  enclosingFunction,
+  holdsBehaviour,
+  isInlineFunction,
+  isVueStateCall,
+  localFunction,
+  makesVueState,
+  returnedFrom,
+  returnsOnlyData
+};

package/plugin/index.js

@@ -0,0 +1,64 @@
+import { actionCreator } from "./rules/actionCreator.js";
+import { actionExecuteShape } from "./rules/actionExecuteShape.js";
+import { allowCommentForm } from "./rules/allowCommentForm.js";
+import { appErrorCode } from "./rules/appErrorCode.js";
+import { collaboratorProps } from "./rules/collaboratorProps.js";
+import { fixedResultShape } from "./rules/fixedResultShape.js";
+import { frozenFactoryResult } from "./rules/frozenFactoryResult.js";
+import { noOptionalAfterDefault } from "./rules/noOptionalAfterDefault.js";
+import { jsdocDescriptionInside } from "./rules/jsdocDescriptionInside.js";
+import { namedRepeatedType } from "./rules/namedRepeatedType.js";
+import { noDualShape } from "./rules/noDualShape.js";
+import { noDuplicateHelper } from "./rules/noDuplicateHelper.js";
+import { noEnvDefault } from "./rules/noEnvDefault.js";
+import { noFactorySpread } from "./rules/noFactorySpread.js";
+import { noFrozenVueState } from "./rules/noFrozenVueState.js";
+import { noIdempotency } from "./rules/noIdempotency.js";
+import { noModuleRegistry } from "./rules/noModuleRegistry.js";
+import { noModuleState } from "./rules/noModuleState.js";
+import { noPatchedError } from "./rules/noPatchedError.js";
+import { noSlotSetter } from "./rules/noSlotSetter.js";
+import { noTestOnlyExport } from "./rules/noTestOnlyExport.js";
+import { oneLineAction } from "./rules/oneLineAction.js";
+import { onePropertyPerLine } from "./rules/onePropertyPerLine.js";
+import { releasedListeners } from "./rules/releasedListeners.js";
+import { requiredCollaborators } from "./rules/requiredCollaborators.js";
+import { typedDependencies } from "./rules/typedDependencies.js";
+import { typedInject } from "./rules/typedInject.js";
+
+// The `jskit` ESLint plugin: the typed-features rules, by name, server and client. Each rule's messages link to the
+// guide section that explains it.
+const jskitPlugin = Object.freeze({
+  meta: Object.freeze({ name: "@jskit-ai/config-eslint/jskit" }),
+  rules: Object.freeze({
+    "typed-dependencies": typedDependencies,
+    "required-collaborators": requiredCollaborators,
+    "no-slot-setter": noSlotSetter,
+    "no-module-registry": noModuleRegistry,
+    "one-line-action": oneLineAction,
+    "no-duplicate-helper": noDuplicateHelper,
+    "allow-comment-form": allowCommentForm,
+    "jsdoc-description-inside": jsdocDescriptionInside,
+    "no-dual-shape": noDualShape,
+    "named-repeated-type": namedRepeatedType,
+    "action-execute-shape": actionExecuteShape,
+    "no-factory-spread": noFactorySpread,
+    "frozen-factory-result": frozenFactoryResult,
+    "no-optional-after-default": noOptionalAfterDefault,
+    "one-property-per-line": onePropertyPerLine,
+    "action-creator": actionCreator,
+    "no-idempotency": noIdempotency,
+    "app-error-code": appErrorCode,
+    "no-patched-error": noPatchedError,
+    "no-env-default": noEnvDefault,
+    "no-test-only-export": noTestOnlyExport,
+    "typed-inject": typedInject,
+    "collaborator-props": collaboratorProps,
+    "fixed-result-shape": fixedResultShape,
+    "released-listeners": releasedListeners,
+    "no-module-state": noModuleState,
+    "no-frozen-vue-state": noFrozenVueState
+  })
+});
+
+export { jskitPlugin };