fake-current-time 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 oreshinya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# fake-current-time
+
+<a href="https://github.com/oreshinya/fake-current-time/actions/workflows/check.yml"><img src="https://img.shields.io/github/actions/workflow/status/oreshinya/fake-current-time/check.yml?branch=main&logo=github&style=flat-square" /></a>
+<a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-brightgreen.svg?style=flat-square" /></a>
+<a href="https://npmjs.org/package/fake-current-time"><img src="https://img.shields.io/npm/v/fake-current-time.svg?style=flat-square" /></a>
+
+Manipulate current time in your application for development and staging environments.
+
+Uses `Proxy` and `AsyncLocalStorage` to isolate time contexts per request, allowing multiple users to test with different time offsets simultaneously.
+
+## Installation
+
+```bash
+npm install fake-current-time
+```
+
+## Usage
+
+This example shows integration with React Router framework mode. The key concept is:
+
+- **Server**: Parse offset from cookie and wrap rendering with `runner.run(offset, ...)`
+- **Client**: Call `setup()` to initialize time manipulation
+- **UI**: Use `setOffset()` and `clearOffset()` to control time via cookie
+
+### Server Entry (`entry.server.tsx`)
+
+```typescript
+import type { AppLoadContext, EntryContext } from "react-router";
+import { setup, parseOffsetFromCookie } from "fake-current-time/node";
+
+// Do NOT setup in production
+const runner = process.env.STAGE !== "production" ? setup() : null;
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: AppLoadContext,
+) {
+  const offset = runner
+    ? parseOffsetFromCookie(request.headers.get("Cookie") || "")
+    : undefined;
+
+  const render = () => {
+    return new Promise((resolve, reject) => {
+      // ...
+      const { pipe, abort } = renderToPipeableStream(/* ... */, {
+        // ...
+      });
+    });
+  };
+
+  return offset && runner ? runner.run(offset, render) : render();
+}
+```
+
+### Client Entry (`entry.client.tsx`)
+
+```typescript
+import { startTransition } from "react";
+import { setup } from "fake-current-time/browser";
+
+// Do NOT setup in production
+if (process.env.STAGE !== "production") {
+  setup();
+}
+
+startTransition(() => {
+  // ...
+});
+```
+
+### UI Component
+
+```typescript
+import { setOffset, clearOffset } from "fake-current-time/browser";
+
+// Restrict access to this page in production (e.g., via routing or middleware)
+export function TimeControl() {
+  return (
+    <div>
+      <p>Current: {new Date().toString()}</p>
+      {/* setOffset saves to cookie and reloads the page */}
+      <button onClick={() => setOffset({ days: 1 })}>+1 Day</button>
+      <button onClick={() => setOffset({ days: -1 })}>-1 Day</button>
+      <button onClick={() => setOffset({ months: 3, days: 7 })}>+3 Months +7 Days</button>
+      {/* clearOffset removes cookie and reloads the page */}
+      <button onClick={clearOffset}>Reset</button>
+    </div>
+  );
+}
+```
+
+`setOffset` accepts: `years`, `months`, `days`, `hours`, `minutes`, `seconds`, `milliseconds`

package/dist/browser.d.ts

@@ -0,0 +1,7 @@
+import { TimeOffset } from './index.js';
+
+declare function setup(): void;
+declare function setOffset(offset: TimeOffset): void;
+declare function clearOffset(): void;
+
+export { clearOffset, setOffset, setup };

package/dist/browser.js

@@ -0,0 +1,32 @@
+import {
+  COOKIE_NAME,
+  encodeOffset,
+  parseOffsetFromCookie,
+  setupDateProxy
+} from "./chunk-APIG4RGO.js";
+
+// src/browser.ts
+var initialized = false;
+function setup() {
+  if (initialized) {
+    return;
+  }
+  setupDateProxy(getOffset);
+  initialized = true;
+}
+function setOffset(offset) {
+  document.cookie = `${COOKIE_NAME}=${encodeOffset(offset)}; path=/`;
+  location.reload();
+}
+function clearOffset() {
+  document.cookie = `${COOKIE_NAME}=; path=/; max-age=0`;
+  location.reload();
+}
+function getOffset() {
+  return parseOffsetFromCookie(document.cookie);
+}
+export {
+  clearOffset,
+  setOffset,
+  setup
+};

package/dist/chunk-APIG4RGO.js

@@ -0,0 +1,86 @@
+// src/cookie.ts
+var COOKIE_NAME = "fake_current_time_offset";
+function parseOffsetFromCookie(cookieString) {
+  if (!cookieString) {
+    return void 0;
+  }
+  const cookies = cookieString.split(";");
+  for (const cookie of cookies) {
+    const [name, value] = cookie.trim().split("=");
+    if (name === COOKIE_NAME && value) {
+      return decodeOffset(value);
+    }
+  }
+  return void 0;
+}
+function encodeOffset(offset) {
+  return JSON.stringify(offset);
+}
+function decodeOffset(value) {
+  return JSON.parse(value);
+}
+
+// src/core.ts
+function setupDateProxy(getOffset) {
+  const OriginalDate = globalThis.Date;
+  const DateProxy = new Proxy(OriginalDate, {
+    construct(target, args, newTarget) {
+      const offset = getOffset();
+      if (offset && args.length === 0) {
+        const t = fakeCurrentTime(OriginalDate, offset);
+        return Reflect.construct(target, [t], newTarget);
+      }
+      return Reflect.construct(target, args, newTarget);
+    },
+    get(target, prop, receiver) {
+      if (prop === "now") {
+        const offset = getOffset();
+        if (offset) {
+          return () => fakeCurrentTime(OriginalDate, offset);
+        }
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    apply(target, thisArg, args) {
+      const offset = getOffset();
+      if (offset && args.length === 0) {
+        const t = fakeCurrentTime(OriginalDate, offset);
+        return new OriginalDate(t).toString();
+      }
+      return Reflect.apply(target, thisArg, args);
+    }
+  });
+  globalThis.Date = DateProxy;
+}
+function fakeCurrentTime(ctor, offset) {
+  const date = new ctor();
+  if (offset.years) {
+    date.setFullYear(date.getFullYear() + offset.years);
+  }
+  if (offset.months) {
+    date.setMonth(date.getMonth() + offset.months);
+  }
+  if (offset.days) {
+    date.setDate(date.getDate() + offset.days);
+  }
+  if (offset.hours) {
+    date.setHours(date.getHours() + offset.hours);
+  }
+  if (offset.minutes) {
+    date.setMinutes(date.getMinutes() + offset.minutes);
+  }
+  if (offset.seconds) {
+    date.setSeconds(date.getSeconds() + offset.seconds);
+  }
+  if (offset.milliseconds) {
+    date.setMilliseconds(date.getMilliseconds() + offset.milliseconds);
+  }
+  return date.getTime();
+}
+
+export {
+  COOKIE_NAME,
+  parseOffsetFromCookie,
+  encodeOffset,
+  setupDateProxy
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+interface TimeOffset {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+
+export type { TimeOffset };

package/dist/node.d.ts

@@ -0,0 +1,10 @@
+import { TimeOffset } from './index.js';
+
+declare function parseOffsetFromCookie(cookieString: string | undefined): TimeOffset | undefined;
+
+interface FakeTimeRunner {
+    run<T>(offset: TimeOffset, callback: () => T): T;
+}
+declare function setup(): FakeTimeRunner;
+
+export { type FakeTimeRunner, parseOffsetFromCookie, setup };

package/dist/node.js

@@ -0,0 +1,25 @@
+import {
+  parseOffsetFromCookie,
+  setupDateProxy
+} from "./chunk-APIG4RGO.js";
+
+// src/node.ts
+import { AsyncLocalStorage } from "async_hooks";
+var runner = null;
+function setup() {
+  if (runner) {
+    return runner;
+  }
+  const storage = new AsyncLocalStorage();
+  setupDateProxy(() => storage.getStore());
+  runner = {
+    run(offset, callback) {
+      return storage.run(offset, callback);
+    }
+  };
+  return runner;
+}
+export {
+  parseOffsetFromCookie,
+  setup
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "fake-current-time",
+  "version": "0.1.0",
+  "description": "Manipulate current time in your application for development and staging environments",
+  "keywords": [
+    "time",
+    "date",
+    "offset",
+    "manipulation",
+    "development",
+    "staging",
+    "simulation"
+  ],
+  "author": "oreshinya",
+  "license": "MIT",
+  "repository": "oreshinya/fake-current-time",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.7",
+    "@types/node": "^24.10.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.3"
+  },
+  "scripts": {
+    "typecheck": "tsc",
+    "lint:ci": "biome ci ./src",
+    "lint:fix": "biome check --write ./src",
+    "test": "vitest run",
+    "build": "tsup"
+  }
+}