glib-web 4.41.0 → 4.41.1

package/.nycrc.json

@@ -0,0 +1,18 @@
+{
+  "reporter": [
+    "text-summary",
+    "html"
+  ],
+  "report-dir": "./coverage",
+  "extension": [
+    ".js",
+    ".ts",
+    ".vue"
+  ],
+  "exclude": [
+    "cypress/**",
+    "coverage/**",
+    "doc/**",
+    "node_modules/**"
+  ]
+}

package/cypress/support/e2e.ts

@@ -15,6 +15,7 @@
 
 // Import commands.js using ES2015 syntax:
 import './commands'
+import '@cypress/code-coverage/support'
 
 // Alternatively you can use CommonJS syntax:
-// require('./commands')
+// require('./commands')

package/cypress.config.ts

@@ -1,9 +1,11 @@
 import { defineConfig } from "cypress";
+import codeCoverageTask from "@cypress/code-coverage/task";
 
 export default defineConfig({
   e2e: {
     setupNodeEvents(on, config) {
-      // implement node event listeners here
+      codeCoverageTask(on, config);
+      return config;
     },
   },
 });

package/doc/TESTING.md

@@ -54,3 +54,17 @@ You **cannot write frontend tests in isolation**.
 ---
 
 These 6 concepts explain **why the test structure exists** and **what you need to get started**. Everything else (selectors, assertions, etc.) is standard Cypress mechanics.
+
+## Cypress Coverage Workflow
+
+- **Prerequisites**: Keep the backend `glib-web` server running with the matching `test_page/*` fixtures (same as normal Cypress runs) and make sure the frontend package is linked into that app: `yarn link glib-web` (run from the backend repo).
+- **Instrument code**: Coverage is only collected when `VITE_COVERAGE=true` because `vite-plugin-istanbul` has `requireEnv` enabled.
+- **Step-by-step run**:
+  1. From the backend repo (`glib-web`), ensure the link is active: `yarn link glib-web`.
+  2. From the backend repo, start Vite with instrumentation: `VITE_COVERAGE=true bin/vite dev`.
+  3. From the backend repo, start Rails: `bin/rails s`.
+  4. From this repo (`glib-web-npm`), execute `yarn test:coverage` to run Cypress and emit coverage reports via `nyc` (uses `.nycrc.json`).
+- **Manual run (if you need custom flags)**:
+  1. `VITE_COVERAGE=true yarn test`
+  2. `nyc report` (or add reporters, e.g. `nyc report --reporter=lcov`).
+- **Where to read results**: HTML report at `coverage/index.html`; summary printed in the terminal; raw data in `.nyc_output` and `coverage/coverage-final.json`.

package/package.json

@@ -1,10 +1,12 @@
 {
+  "type": "module",
   "name": "glib-web",
-  "version": "4.41.0",
+  "version": "4.41.1",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "cypress run --browser chrome"
+    "test": "cypress run --browser chrome",
+    "test:coverage": "VITE_COVERAGE=true cypress run --browser chrome && nyc report"
   },
   "author": "",
   "license": "ISC",
@@ -42,11 +44,18 @@
     "vuetify": "3.8.6"
   },
   "devDependencies": {
+    "@cypress/code-coverage": "^3.14.7",
     "@types/chart.js": "^2.9.34",
+    "@vitejs/plugin-vue": "^6.0.2",
     "cypress": "^13.13.1",
     "eslint": "^8.36.0",
     "eslint-plugin-vue": "^9.26.0",
     "prettier": "^1.18.2",
-    "typescript": "^4.9.5"
+    "typescript": "^4.9.5",
+    "vite": "^7.2.7",
+    "vite-plugin-compression": "^0.5.1",
+    "vite-plugin-environment": "^1.1.3",
+    "vite-plugin-istanbul": "^7.2.1",
+    "vite-plugin-ruby": "^5.1.1"
   }
 }

package/plugins/viteDefaultConfig.js

@@ -0,0 +1,88 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import RubyPlugin from "vite-plugin-ruby";
+import vue from "@vitejs/plugin-vue";
+import viteCompression from "vite-plugin-compression";
+import EnvironmentPlugin from "vite-plugin-environment";
+import istanbul from "vite-plugin-istanbul";
+import * as TypeUtils from "../utils/type.js";
+
+function pickStringArray(value) {
+  if (!TypeUtils.isArray(value)) {
+    return null;
+  }
+
+  const filtered = value.filter((item) => TypeUtils.isString(item));
+  return filtered.length > 0 ? filtered : null;
+}
+
+function resolveGlibRoot(customRoot) {
+  if (TypeUtils.isString(customRoot)) {
+    return customRoot;
+  }
+
+  return path.resolve(fileURLToPath(new URL("..", import.meta.url)));
+}
+
+
+/**
+ * Builds the default Vite configuration used by glib projects.
+ *
+ * @param {object} [options] Configuration overrides.
+ * @param {string} [options.glibRoot] Root directory for the glib package (defaults to repo root).
+ * @param {string} [options.aliasName] Module alias name for glib imports.
+ * @param {string} [options.aliasPath] Filesystem path used for the alias.
+ * @param {string} [options.workspaceRoot] Workspace root for coverage and path resolution.
+ * @param {string[]} [options.istanbulInclude] Globs to include when running Istanbul.
+ * @param {string[]} [options.environmentVariables] Environment variables exposed to the client.
+ * @param {string[]} [options.serverAllow] Additional filesystem paths allowed by Vite dev server.
+ * @param {import("vite").Plugin[]} [options.plugins] Extra Vite plugins to append.
+ * @returns {import("vite").UserConfig} Config object passed to `defineConfig`.
+ */
+function useGlibViteDefineConfig(options = {}) {
+  if (TypeUtils.isNotNull(globalThis.window)) {
+    throw new Error("useGlibViteDefineConfig is only available in Node environments.");
+  }
+
+  const configOptions = TypeUtils.isObject(options) && !TypeUtils.isArray(options) ? options : {};
+
+  const glibRoot = resolveGlibRoot(configOptions.glibRoot);
+  const aliasName = TypeUtils.isString(configOptions.aliasName) ? configOptions.aliasName : "glib-web";
+  const aliasPath = TypeUtils.isString(configOptions.aliasPath) ? configOptions.aliasPath : glibRoot;
+  const workspaceRoot = TypeUtils.isString(configOptions.workspaceRoot)
+    ? configOptions.workspaceRoot
+    : path.resolve(glibRoot, "..");
+  const istanbulInclude = pickStringArray(configOptions.istanbulInclude) ?? [`${path.basename(glibRoot)}/**/*`];
+  const environmentVariables = pickStringArray(configOptions.environmentVariables) ?? ["VITE_GMAPS_API_KEY"];
+  const serverAllow = pickStringArray(configOptions.serverAllow) ?? [glibRoot];
+  const additionalPlugins = TypeUtils.isArray(configOptions.plugins) ? configOptions.plugins : [];
+
+  return defineConfig({
+    server: {
+      fs: {
+        allow: serverAllow.map((allowedPath) => path.resolve(allowedPath))
+      }
+    },
+    resolve: {
+      alias: {
+        [aliasName]: path.resolve(aliasPath)
+      }
+    },
+    plugins: [
+      vue(),
+      RubyPlugin(),
+      istanbul({
+        cwd: path.resolve(workspaceRoot),
+        include: istanbulInclude,
+        requireEnv: true
+      }),
+      viteCompression(),
+      EnvironmentPlugin(environmentVariables, { defineOn: "import.meta.env" }),
+      ...additionalPlugins
+    ]
+  });
+}
+
+export { useGlibViteDefineConfig };
+export default useGlibViteDefineConfig;

package/utils/type.js

@@ -1,4 +1,4 @@
-import Hash from "./hash";
+import Hash from "./hash.js";
 
 export function isObject(obj) {
   return typeof obj === "object" && obj !== null;