placementt-core 1.400.961 → 1.400.963

package/README.md

@@ -0,0 +1,56 @@
+# placementt-core
+
+Shared code (types, Firebase helpers, utilities, shared UI) used by `placementt-web`, `placementt-backend`, and `placementt-app`.
+
+## Testing local changes before publishing
+
+Normally, `placementt-web` and `placementt-backend` depend on published npm versions of this package (via the `dev`/`prod`/`emu` dist-tags). While you're working on a change here, you don't want to publish to npm just to test it — instead, build it locally and link it into the consuming repo with [yalc](https://github.com/wclr/yalc).
+
+### 1. Publish your local changes to the yalc store
+
+From this repo, run:
+
+```
+yarn test-local dev    # or: yarn test-local d
+yarn test-local prod   # or: yarn test-local p
+```
+
+This builds your current working tree (including uncommitted changes) with the chosen config flavor (dev swaps in dev Firebase config/credentials, prod leaves it as-is), then publishes it to your local yalc store under a fixed sentinel version (`0.0.0-local-dev` / `0.0.0-local-prod`). It restores all the swapped files afterward, so your working tree is left clean.
+
+Re-run this command any time you make further changes you want to test — it always re-publishes over the same sentinel version.
+
+### 2. Pull it into placementt-web or placementt-backend
+
+From `placementt-web` or `placementt-backend`, run:
+
+```
+yarn core dev     # or: yarn core d
+yarn core prod    # or: yarn core p
+```
+
+This checks whether a matching local yalc build exists (published in step 1). If it does, it links your local build in via `yalc add` instead of installing from npm. If it doesn't, it falls back to installing the real published `dev`/`prod` dist-tag from npm as normal.
+
+Match the flavor to what you published in step 1 (`dev` ↔ `dev`, `prod` ↔ `prod`).
+
+### 3. Restart the dev server/emulator to pick it up
+
+Neither CRA's dev server nor the Firebase emulator watches `node_modules` for changes, so you need to restart after linking. Add `--restart` (or `-r`) to the same command to do this in one step:
+
+```
+yarn core dev --restart     # or: yarn core d -r
+```
+
+- **placementt-web**: kills whatever's running on port 3000, clears `node_modules/.cache`, and runs `yarn start`.
+- **placementt-backend**: rebuilds the functions bundle (`npm run build`) and starts the functions emulator (`firebase emulators:start --only functions`).
+
+### Full loop
+
+```
+# in placementt-core, after making changes
+yarn test-local dev
+
+# in placementt-web and/or placementt-backend
+yarn core dev --restart
+```
+
+Repeat step 1 + step 3 as you iterate. Once you're happy with the change, commit it here, bump the version, and publish for real (`yarn deploy` / `yarn deploy-all`) — then re-run `yarn core dev` (or `prod`) in the consuming repos without `--restart` to drop back to the real published version instead of the local link.

package/package.json

@@ -2,7 +2,7 @@
   "private": false,
   "name": "placementt-core",
   "author": "Placementt",
-  "version": "1.400.961",
+  "version": "1.400.963",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -14,7 +14,8 @@
     "pack": "yarn pack",
     "deploy": "tsc && yarn publish",
     "deploy-all": "node deploy-all.js",
-    "test-local": "node test-local.js"
+    "test-local": "node test-local.js",
+    "watch-local": "node watch-local.js"
   },
   "peerDependencies": {
     "@reduxjs/toolkit": "^2.0.0",

package/watch-local.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Watch mode for the local yalc dev loop: keeps `tsc --watch` running against
+// the current working tree (including uncommitted changes), and on every
+// successful compile runs `yalc push`, which republishes the sentinel
+// version and pushes the update into any project that has already run
+// `yalc add placementt-core@<sentinel>` (i.e. already run `yarn core d` /
+// `yarn core p` once). Mirrors the config-swap logic in test-local.js, but
+// swaps once for the whole session instead of once per build.
+const fs = require("fs");
+const {execSync, spawn} = require("child_process");
+
+const flagMap = {
+    "prod": "prod",
+    "dev": "dev",
+    "p": "prod",
+    "d": "dev",
+};
+
+const flag = process.argv.find((arg) => Object.keys(flagMap).includes(arg));
+
+if (!flag) {
+    console.error("Usage: yarn watch-local dev | yarn watch-local prod (or -d / -p)");
+    process.exit(1);
+}
+
+const target = flagMap[flag];
+const localVersion = target === "dev" ? "0.0.0-local-dev" : "0.0.0-local-prod";
+
+const packageJsonPath = "package.json";
+const firebaseConfigPath = "src/firebase/firebaseConfig.tsx";
+const hooksPath = "src/hooks.tsx";
+
+const originalPackageJson = fs.readFileSync(packageJsonPath, "utf8");
+const originalFirebaseConfig = fs.readFileSync(firebaseConfigPath, "utf8");
+const originalHooks = fs.readFileSync(hooksPath, "utf8");
+
+let restored = false;
+function restore() {
+    if (restored) return;
+    restored = true;
+    fs.writeFileSync(packageJsonPath, originalPackageJson);
+    fs.writeFileSync(firebaseConfigPath, originalFirebaseConfig);
+    fs.writeFileSync(hooksPath, originalHooks);
+    try {
+        execSync("git checkout -- lib", {stdio: "inherit"});
+    } catch (e) {
+        console.warn("⚠️ Could not reset lib/ via git checkout — check `git status`.");
+    }
+}
+
+const packageJson = JSON.parse(originalPackageJson);
+packageJson.version = localVersion;
+fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+
+if (target === "dev") {
+    console.log("🛠 Switching to DEV config for this watch session...");
+    fs.writeFileSync(
+        firebaseConfigPath,
+        originalFirebaseConfig.replace(/\(credentialsProd\)/g, "(credentialsDev)"),
+    );
+    fs.writeFileSync(
+        hooksPath,
+        originalHooks.replace(/XMPXCMUUOJ/g, "A0ZB50I7VS"),
+    );
+} else {
+    console.log("🛠 Using PROD config (unmodified) for this watch session...");
+}
+
+console.log(`👀 Watching src/ — every successful compile is pushed to yalc as ${localVersion}.`);
+console.log(`   First time only: run \`yarn core ${flag}\` in placementt-web / placementt-backend to link it.`);
+
+const tsc = spawn("node_modules/.bin/tsc", ["--watch", "--preserveWatchOutput"], {
+    stdio: ["ignore", "pipe", "inherit"],
+});
+
+tsc.stdout.on("data", (chunk) => {
+    const text = chunk.toString();
+    process.stdout.write(text);
+    if (/Found 0 errors\./.test(text)) {
+        try {
+            execSync("yalc push", {stdio: "inherit"});
+        } catch (e) {
+            console.error("⚠️ yalc push failed:", e.message);
+        }
+    }
+});
+
+tsc.on("exit", (code) => {
+    restore();
+    process.exit(code ?? 0);
+});
+
+process.on("SIGINT", () => {
+    tsc.kill("SIGINT");
+});
+process.on("SIGTERM", () => {
+    tsc.kill("SIGTERM");
+});
+process.on("exit", restore);