@mtorre4580/is-deprecated 0.0.2 → 1.0.0

package/README.md

@@ -1,89 +1,173 @@
 # is-deprecated
 
-A utility library designed to notify about deprecated functions or methods within objects.
+Runtime deprecation warnings for functions, methods, properties and classes, for **Node and the browser**, with **TypeScript types**, **decorators**, **telemetry hooks** and **warn / throw / silent** modes. Zero dependencies.
 
-<img  width="128" height="128" src="https://github.com/mtorre4580/is-deprecated/blob/main/deprecated.png?raw=true" />
-
-## Installation
+<img width="128" height="128" src="https://github.com/mtorre4580/is-deprecated/blob/main/deprecated.png?raw=true" />
 
 ```
 npm i @mtorre4580/is-deprecated
 ```
 
-## Parameters
+```ts
+import { deprecate } from '@mtorre4580/is-deprecated';
+
+export const getUsers = deprecate(getUsersImpl, {
+  since: '1.4.0',
+  removeIn: '2.0.0',
+  replacement: 'getUsersV2()',
+});
+
+getUsers();
+// (node:4242) DeprecationWarning: getUsers is deprecated since 1.4.0 and will be removed in 2.0.0. Use getUsersV2() instead.
+// Called from file:///app/src/routes.ts:12:3
+```
+
+## Why this one
+
+| | is-deprecated | [depd](https://www.npmjs.com/package/depd) | [util-deprecate](https://www.npmjs.com/package/util-deprecate) | Node `util.deprecate` |
+|---|:-:|:-:|:-:|:-:|
+| Works in browsers | ✅ | ❌ (no-op) | ✅ | ❌ |
+| TypeScript types included | ✅ | ❌ | ❌ | ✅ |
+| Functions and classes (`new`) | ✅ | ✅ | ✅ | ✅ |
+| Object methods and properties | ✅ | ✅ | ❌ | ❌ |
+| Decorators (TC39 + legacy) | ✅ | ❌ | ❌ | ❌ |
+| Call site in the warning | ✅ | ✅ | ❌ | with `--trace-deprecation` |
+| Once per call site | ✅ | ✅ | once total | once total |
+| `since` / `removeIn` / `replacement` metadata | ✅ | ❌ | ❌ | `code` only |
+| Overdue removal dates | ✅ | ❌ | ❌ | ❌ |
+| Telemetry hook with structured event | ✅ | `process.on('deprecation')` | ❌ | `process.on('warning')` |
+| Modes warn / throw / silent | ✅ | ✅ (Node flags) | partial | ✅ (Node flags) |
+| ESM + CJS | ✅ | CJS | CJS | n/a |
+
+If you only target Node and need to deprecate a single function, `util.deprecate` is perfectly fine. Use this library when you ship code to browsers, want typed metadata, decorators or telemetry.
 
-- obj (Object|Function): The object or function to check for deprecation.
+## API
 
-- config (Object): Configuration object with the following properties:
-  - method (String): The method name to be deprecated within the object.
-  - message (String): Custom deprecation message (default: 'This will be deprecated soon').
-  - logger (Object): Logger object for warning messages (default: console).
-  - sendMetrics (Function): Function to send metrics upon deprecation (default: empty function).
+### `deprecate(fn, options?)`
 
-## Usage
+Wraps a function or class. It warns **when called** (or instantiated with `new`), never when wrapped. It keeps `this`, `new`, `instanceof`, `name`, `length`, `prototype` and static members.
 
-Function to notify about deprecation and wrap the function/method with deprecation warnings.
+```ts
+const LegacyClient = deprecate(Client, { replacement: 'ApiClient' });
+new LegacyClient(); // Client is deprecated. Use ApiClient instead.
+```
+
+### `deprecateMethod(obj, method | methods[], options?)`
 
-<img alt="example usage" src="https://github.com/mtorre4580/is-deprecated/blob/main/example_usage.png?raw=true" />
+Returns a proxy of `obj` whose methods warn when **called**. Reading the property, `typeof`, spreading or logging the object does not warn. Deprecated methods run against the original object, so private fields work and their internal `this.x()` calls are not reported again.
+
+```ts
+export const api = deprecateMethod(apiImpl, ['getUsers', 'getUser'], {
+  removeIn: '2027-06-30',
+  url: 'https://example.com/migrate-users',
+});
+```
 
-### With Function
+### `deprecateProperty(obj, property, options?)`
+
+Redefines the property **in place** so reading or writing it warns. It works with data properties and with getters/setters.
+
+```ts
+deprecateProperty(config, 'retries', { replacement: 'config.maxRetries' });
+```
 
-```js
-import deprecated from "@mtorre4580/is-deprecated";
+### `@Deprecated(options?)`
 
-// Function to add the deprecated helper
-const myFunction = (arg1, arg2) => {};
+Decorator for classes, methods, getters, setters and `accessor` fields. It supports standard decorators (TypeScript 5+, Babel) and legacy `experimentalDecorators` (Angular, NestJS).
 
-// Basic config
-const config = {
-  message:
-    "myFunction will be removed in the next release, please replace with this https://www.npmjs.com",
-};
+```ts
+import { Deprecated } from '@mtorre4580/is-deprecated';
 
-// Create the wrapper to use
-const deprecatedMyFunction = deprecated(myFunction, config);
+class Api {
+  /** @deprecated Use {@link Api.getUsersV2} */
+  @Deprecated({ since: '1.2.0', replacement: 'Api.getUsersV2()' })
+  getUsers() {}
 
-// Call the wrapper function to see the warning
-deprecatedMyFunction('', {});
+  @Deprecated()
+  accessor timeout = 5000;
+}
+// Api.getUsers() is deprecated since 1.2.0. Use Api.getUsersV2() instead.
 ```
 
-### With Function in Object
-
-```js
-import deprecated from "@mtorre4580/is-deprecated";
-
-// Object to apply the deprecated method
-const API = {
-  timeout: 5000,
-  getUsers() {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve([
-          { id: 2, name: "Matias" },
-          { id: 3, name: "Belen" },
-        ]);
-      }, 1000);
-    });
+Plain class fields cannot be intercepted: use `accessor` or a getter/setter.
+
+### Options
+
+| Option | Type | Description |
+|---|---|---|
+| `name` | `string` | Name shown in the message. Defaults to the function, method or property name. |
+| `message` | `string` | Full custom message (replaces the generated one). |
+| `since` | `string` | Version in which the API was deprecated. |
+| `removeIn` | `string \| Date` | Version (`"2.0.0"`) or date (`"2027-01-01"`) of removal. Past dates are marked `[OVERDUE]` and logged with `logger.error` when available. |
+| `replacement` | `string` | What to use instead. |
+| `code` | `string` | Stable id such as `MYLIB_DEP001`. Shown by Node and used for dedupe. |
+| `url` | `string` | Migration guide. |
+| `once` | `boolean` | Warn once per call site (default `true`). |
+| `logger` | `{ warn, error? }` | Logger for this API. |
+| `onDeprecation` | `(event) => void` | Telemetry hook for this API. |
+
+### `configure(config)`
+
+```ts
+import { configure } from '@mtorre4580/is-deprecated';
+
+configure({
+  mode: process.env.NODE_ENV === 'production' ? 'silent' : 'warn', // or 'throw' in CI
+  once: true,
+  logger: pinoLogger, // default: process.emitWarning in Node, console.warn in browsers
+  onDeprecation(event) {
+    metrics.increment('deprecated_api', { name: event.name, code: event.code });
   },
-  getUsersV2() {},
-};
+});
+```
+
+- **`warn`** (default) prints the warning.
+- **`throw`** throws a `DeprecationError` on every call (`error.event` holds the details). It is handy in CI to make sure nothing still uses old APIs.
+- **`silent`** prints nothing but **still calls `onDeprecation`**, so you can track usage in production without noise.
 
-// Basic config
-const config = {
-  message: "getUsers is deprecated in the next release, please with getUsersV2",
-  method: "getUsers",
-};
+When `mode` is not configured it is read from the `IS_DEPRECATED_MODE` env var (`warn|throw|silent`), and then from Node's `--no-deprecation` / `--throw-deprecation` flags.
 
-// Create the wrapper to use
-const APIWithDeprecated = deprecated(API, config);
+The `onDeprecation` event has this shape:
 
-// Call the wrapper function to see the warning
-const users = await APIWithDeprecated.getUsers();
+```ts
+{ name, message, code?, since?, removeIn?, replacement?, url?, overdue, callSite?, stack?, mode }
 ```
 
-## Best Practices
+Hooks that throw are ignored: telemetry never breaks your app.
+
+### `resetDeprecations()`
+
+Clears the "already warned" cache. It is useful in tests.
+
+## Best practices
+
+- Combine the static and runtime signals: the JSDoc `/** @deprecated */` tag strikes the API through in editors and is caught by [`@typescript-eslint/no-deprecated`](https://typescript-eslint.io/rules/no-deprecated/), while this library warns people who use it at runtime or from plain JavaScript.
+- Always set `replacement` and `removeIn`, so a warning tells people what to do and by when.
+- Use `code` so people can search for it and filter it with Node's `--no-deprecation`/`process.on('warning')`.
+- Send `onDeprecation` to your metrics, so you know when it is safe to remove the API.
+
+## Migrating from 0.x
+
+The 0.x default export still works but is deprecated:
+
+```diff
+- import deprecated from '@mtorre4580/is-deprecated';
+- const fn = deprecated(myFn, { message: '...' });
+- const api = deprecated(API, { method: 'getUsers', sendMetrics });
++ import { deprecate, deprecateMethod } from '@mtorre4580/is-deprecated';
++ const fn = deprecate(myFn, { message: '...' });
++ const api = deprecateMethod(API, 'getUsers', { onDeprecation });
+```
+
+Behavior changes in 1.0:
+
+- **Bug fix:** in 0.x a wrapped function warned once when it was *wrapped* and never when it was *called*. It now warns on calls.
+- Object methods warn when called, not on every property read.
+- Warnings are deduplicated per call site (`once: false` restores warning on every call).
+- The default message is generated from the metadata instead of `"This will be deprecated soon"`.
+- `sendMetrics` now receives the event object.
+- In CommonJS, `require()` returns the module namespace: use `const { deprecate } = require('@mtorre4580/is-deprecated')`.
+
+## License
 
-- To building time use the jsdoc decorator [@deprecated](https://jsdoc.app/tags-deprecated) in the code
-- To runtime use the function from this lib `deprecated` to notify in the console
-- The sendMetrics function allows to get more insight what app is using the deprecated method to notify the team
-- You can use any environment variable to apply the wrapper or not, if you only need to run in development or staging
+MIT

package/dist/index.cjs

@@ -0,0 +1,347 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/env.ts
+function getProcess() {
+  const proc = globalThis.process;
+  return proc && typeof proc === "object" ? proc : void 0;
+}
+var MODES = ["warn", "throw", "silent"];
+function modeFromEnvironment() {
+  const proc = getProcess();
+  let fromEnv;
+  try {
+    fromEnv = proc?.env?.IS_DEPRECATED_MODE;
+  } catch {
+  }
+  const normalized = fromEnv?.trim().toLowerCase();
+  if (normalized && MODES.includes(normalized)) return normalized;
+  if (proc?.noDeprecation) return "silent";
+  if (proc?.throwDeprecation) return "throw";
+  return "warn";
+}
+function nodeEmitWarning() {
+  const emit = getProcess()?.emitWarning;
+  return typeof emit === "function" ? emit.bind(getProcess()) : void 0;
+}
+
+// src/core.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@mtorre4580/is-deprecated");
+var store = globalThis;
+var state = store[STATE_KEY] ?? (store[STATE_KEY] = { config: {}, seen: /* @__PURE__ */ new Set() });
+function configure(config) {
+  Object.assign(state.config, config);
+  return { ...state.config };
+}
+function resetDeprecations() {
+  state.seen.clear();
+}
+var DeprecationError = class extends Error {
+  constructor(event) {
+    super(event.message);
+    this.name = "DeprecationError";
+    this.code = event.code;
+    this.event = event;
+  }
+};
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}/;
+function parseRemoval(removeIn) {
+  if (removeIn instanceof Date) {
+    return Number.isNaN(removeIn.getTime()) ? {} : { label: removeIn.toISOString().slice(0, 10), date: removeIn };
+  }
+  if (typeof removeIn !== "string" || removeIn === "") return {};
+  if (ISO_DATE.test(removeIn)) {
+    const date = new Date(removeIn);
+    if (!Number.isNaN(date.getTime())) return { label: removeIn, date };
+  }
+  return { label: removeIn };
+}
+function buildMessage(options, name, removal, overdue) {
+  let message = options.message;
+  if (message === void 0) {
+    message = `${name} is deprecated`;
+    if (options.since) message += ` since ${options.since}`;
+    if (removal.label) {
+      if (overdue) message += ` and was scheduled for removal on ${removal.label}`;
+      else message += ` and will be removed ${removal.date ? "on" : "in"} ${removal.label}`;
+    }
+    message += ".";
+    if (options.replacement) message += ` Use ${options.replacement} instead.`;
+    if (options.url) message += ` See ${options.url}`;
+  }
+  return overdue ? `[OVERDUE] ${message}` : message;
+}
+function captureCallSite(boundary) {
+  const E = Error;
+  const holder = {};
+  const previousLimit = E.stackTraceLimit;
+  let skip = 0;
+  try {
+    if (typeof previousLimit === "number") E.stackTraceLimit = 10;
+    if (typeof E.captureStackTrace === "function") {
+      E.captureStackTrace(holder, boundary);
+    } else {
+      holder.stack = new Error().stack;
+      skip = 3;
+    }
+    void holder.stack;
+  } catch {
+    return {};
+  } finally {
+    if (typeof previousLimit === "number") E.stackTraceLimit = previousLimit;
+  }
+  if (typeof holder.stack !== "string") return {};
+  const frames = holder.stack.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !/^Error\b/.test(line)).slice(skip);
+  if (frames.length === 0) return {};
+  return {
+    callSite: frames[0].replace(/^at\s+/, ""),
+    stack: frames.join("\n")
+  };
+}
+function safeCall(hook, event) {
+  if (typeof hook !== "function") return;
+  try {
+    hook(event);
+  } catch {
+  }
+}
+function notify(options, fallbackName, boundary) {
+  const { config } = state;
+  const mode = config.mode ?? modeFromEnvironment();
+  const name = options.name ?? fallbackName;
+  const { callSite, stack } = captureCallSite(boundary);
+  if (mode !== "throw" && (options.once ?? config.once ?? true)) {
+    const key = `${options.code ?? ""}|${name}|${callSite ?? ""}`;
+    if (state.seen.has(key)) return;
+    state.seen.add(key);
+  }
+  const removal = parseRemoval(options.removeIn);
+  const overdue = removal.date !== void 0 && removal.date.getTime() <= Date.now();
+  const message = buildMessage(options, name, removal, overdue);
+  const event = {
+    name,
+    message,
+    code: options.code,
+    since: options.since,
+    removeIn: removal.label,
+    replacement: options.replacement,
+    url: options.url,
+    overdue,
+    callSite,
+    stack,
+    mode
+  };
+  safeCall(config.onDeprecation, event);
+  safeCall(options.onDeprecation, event);
+  safeCall(options.sendMetrics, event);
+  if (mode === "silent") return;
+  if (mode === "throw") throw new DeprecationError(event);
+  const logger = options.logger ?? config.logger;
+  if (logger) {
+    if (overdue && typeof logger.error === "function") logger.error(message);
+    else logger.warn(message);
+    return;
+  }
+  const emitWarning = nodeEmitWarning();
+  if (emitWarning) {
+    emitWarning(message, {
+      type: "DeprecationWarning",
+      code: options.code,
+      detail: callSite ? `Called from ${callSite}` : void 0
+    });
+    return;
+  }
+  if (typeof console !== "undefined") {
+    console.warn(`DeprecationWarning: ${message}${callSite ? `
+    at ${callSite}` : ""}`);
+  }
+}
+function copyFunctionShape(target, source) {
+  for (const key of ["name", "length"]) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (descriptor) Object.defineProperty(target, key, { ...descriptor, configurable: true });
+  }
+}
+function deprecate(fn, options = {}) {
+  if (typeof fn !== "function") {
+    throw new TypeError("deprecate() expects a function or class as first argument");
+  }
+  const fallbackName = fn.name || "anonymous function";
+  const handler = {
+    apply(target, thisArg, args) {
+      notify(options, fallbackName, handler.apply);
+      return Reflect.apply(target, thisArg, args);
+    },
+    construct(target, args, newTarget) {
+      notify(options, fallbackName, handler.construct);
+      return Reflect.construct(target, args, newTarget);
+    }
+  };
+  return new Proxy(fn, handler);
+}
+function deprecateMethod(obj, methods, options = {}) {
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError("deprecateMethod() expects an object as first argument");
+  }
+  const keys = Array.isArray(methods) ? methods : [methods];
+  if (keys.length === 0) throw new TypeError("deprecateMethod() expects at least one method name");
+  for (const key of keys) {
+    if (typeof obj[key] !== "function") {
+      throw new TypeError(`"${String(key)}" is not a method of the given object`);
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const proxy = new Proxy(obj, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function" || !keys.includes(property)) return value;
+      const original = value;
+      const cached = cache.get(property);
+      if (cached && cached.original === original) return cached.wrapped;
+      const methodOptions = keys.length === 1 ? options : { ...options, name: void 0 };
+      const wrapped = function deprecatedMethod(...args) {
+        notify(methodOptions, String(property), wrapped);
+        return Reflect.apply(original, this === proxy ? target : this, args);
+      };
+      copyFunctionShape(wrapped, original);
+      cache.set(property, { original, wrapped });
+      return wrapped;
+    }
+  });
+  return proxy;
+}
+function deprecateProperty(obj, property, options = {}) {
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError("deprecateProperty() expects an object as first argument");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(obj, property);
+  if (!descriptor) throw new TypeError(`"${String(property)}" is not an own property of the given object`);
+  if (!descriptor.configurable) throw new TypeError(`"${String(property)}" is not configurable`);
+  const name = options.name ?? String(property);
+  const next = { configurable: true, enumerable: descriptor.enumerable };
+  if ("value" in descriptor || "writable" in descriptor) {
+    let current = descriptor.value;
+    next.get = function get() {
+      notify(options, name, get);
+      return current;
+    };
+    if (descriptor.writable) {
+      next.set = function set(value) {
+        notify(options, name, set);
+        current = value;
+      };
+    }
+  } else {
+    const { get: originalGet, set: originalSet } = descriptor;
+    if (originalGet) {
+      next.get = function get() {
+        notify(options, name, get);
+        return originalGet.call(this);
+      };
+    }
+    if (originalSet) {
+      next.set = function set(value) {
+        notify(options, name, set);
+        originalSet.call(this, value);
+      };
+    }
+  }
+  Object.defineProperty(obj, property, next);
+  return obj;
+}
+
+// src/decorator.ts
+function isStandardContext(context) {
+  return typeof context === "object" && context !== null && "kind" in context;
+}
+function ownerName(instanceOrClass, isStatic) {
+  try {
+    const owner = isStatic ? instanceOrClass : instanceOrClass?.constructor;
+    return typeof owner?.name === "string" && owner.name !== "" ? owner.name : "Object";
+  } catch {
+    return "Object";
+  }
+}
+function wrapCallable(original, member, isStatic, suffix, options) {
+  const wrapped = function(...args) {
+    notify(options, `${ownerName(this, isStatic)}.${member}${suffix}`, wrapped);
+    return original.apply(this, args);
+  };
+  Object.defineProperty(wrapped, "name", { value: original.name, configurable: true });
+  return wrapped;
+}
+function fieldError() {
+  return new TypeError(
+    "@Deprecated() cannot intercept plain class fields: use an `accessor` field or a getter/setter"
+  );
+}
+function decorateStandard(value, context, options) {
+  const member = String(context.name);
+  const isStatic = Boolean(context.static);
+  switch (context.kind) {
+    case "class":
+      return deprecate(value, { ...options, name: options.name ?? (member || value.name) });
+    case "method":
+      return wrapCallable(value, member, isStatic, "()", options);
+    case "getter":
+    case "setter":
+      return wrapCallable(value, member, isStatic, "", options);
+    case "accessor": {
+      const get = function() {
+        notify(options, `${ownerName(this, isStatic)}.${member}`, get);
+        return value.get.call(this);
+      };
+      const set = function(next) {
+        notify(options, `${ownerName(this, isStatic)}.${member}`, set);
+        value.set.call(this, next);
+      };
+      return { get, set, init: (initial) => initial };
+    }
+    default:
+      throw fieldError();
+  }
+}
+function decorateLegacy(target, key, descriptor, options) {
+  if (key === void 0 && typeof target === "function") {
+    return deprecate(target, { ...options, name: options.name ?? target.name });
+  }
+  if (!descriptor) throw fieldError();
+  const member = String(key);
+  const isStatic = typeof target === "function";
+  const next = { ...descriptor };
+  if (typeof descriptor.value === "function") {
+    next.value = wrapCallable(descriptor.value, member, isStatic, "()", options);
+  }
+  if (descriptor.get) next.get = wrapCallable(descriptor.get, member, isStatic, "", options);
+  if (descriptor.set) next.set = wrapCallable(descriptor.set, member, isStatic, "", options);
+  return next;
+}
+function Deprecated(options = {}) {
+  return function deprecatedDecorator(value, context, descriptor) {
+    if (isStandardContext(context)) return decorateStandard(value, context, options);
+    return decorateLegacy(value, context, descriptor, options);
+  };
+}
+
+// src/index.ts
+function deprecated(obj, config = {}) {
+  if (obj == null) throw new TypeError("The param obj is required");
+  const { method, ...options } = config;
+  if (typeof obj === "function" && method === void 0) {
+    return deprecate(obj, options);
+  }
+  if (method === void 0 || typeof obj[method] !== "function") {
+    throw new TypeError("The object not have the method defined");
+  }
+  return deprecateMethod(obj, method, options);
+}
+
+exports.Deprecated = Deprecated;
+exports.DeprecationError = DeprecationError;
+exports.configure = configure;
+exports.default = deprecated;
+exports.deprecate = deprecate;
+exports.deprecateMethod = deprecateMethod;
+exports.deprecateProperty = deprecateProperty;
+exports.resetDeprecations = resetDeprecations;

package/dist/index.d.cts

@@ -0,0 +1,130 @@
+/** How deprecations are surfaced. */
+type DeprecationMode = 'warn' | 'throw' | 'silent';
+/** Anything with a `warn` method (console, pino, winston, a custom logger...). */
+interface Logger {
+    warn: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+}
+/** Metadata describing a single deprecated API. */
+interface DeprecationOptions {
+    /** Human readable name of the deprecated API. Defaults to the function/property name. */
+    name?: string;
+    /** Full custom message. When omitted, a message is built from the other fields. */
+    message?: string;
+    /** Version (or date) in which the API was deprecated, e.g. `"1.4.0"`. */
+    since?: string;
+    /**
+     * Version or date in which the API will be removed, e.g. `"2.0.0"`, `"2027-01-01"` or a `Date`.
+     * When it is a date that already passed, the deprecation is flagged as overdue.
+     */
+    removeIn?: string | Date;
+    /** What to use instead, e.g. `"getUsersV2()"`. */
+    replacement?: string;
+    /** Stable identifier, e.g. `"MYLIB_DEP001"`. Used for dedupe and shown in Node warnings. */
+    code?: string;
+    /** Link to the migration guide. */
+    url?: string;
+    /** Warn only once per call site (default: global `once`, which defaults to `true`). */
+    once?: boolean;
+    /** Per-API logger. When set, it is used instead of `process.emitWarning`/`console.warn`. */
+    logger?: Logger;
+    /** Per-API telemetry hook, called in addition to the global `onDeprecation`. */
+    onDeprecation?: (event: DeprecationEvent) => void;
+    /**
+     * @deprecated Use `onDeprecation` instead. Kept for compatibility with v0.x.
+     */
+    sendMetrics?: (event: DeprecationEvent) => void;
+}
+/** Payload delivered to `onDeprecation` hooks. */
+interface DeprecationEvent {
+    name: string;
+    message: string;
+    code?: string;
+    since?: string;
+    removeIn?: string;
+    replacement?: string;
+    url?: string;
+    /** `true` when `removeIn` is a date that already passed. */
+    overdue: boolean;
+    /** First stack frame outside this library (best effort, `undefined` when unavailable). */
+    callSite?: string;
+    /** Stack trace starting at the caller (best effort). */
+    stack?: string;
+    /** Mode that was applied to this event. */
+    mode: DeprecationMode;
+}
+/** Global configuration, set with `configure()`. */
+interface GlobalConfig {
+    /**
+     * `warn` (default), `throw` or `silent`. When not set, it is read from the
+     * `IS_DEPRECATED_MODE` env var, then from Node's `--no-deprecation` / `--throw-deprecation`.
+     */
+    mode?: DeprecationMode;
+    /** Warn only once per API and call site. Default `true`. */
+    once?: boolean;
+    /** Global logger. Default: `process.emitWarning` in Node, `console.warn` elsewhere. */
+    logger?: Logger;
+    /** Global telemetry hook. Called even in `silent` mode. */
+    onDeprecation?: (event: DeprecationEvent) => void;
+}
+
+type AnyFunction = (...args: any[]) => any;
+/**
+ * Set global behavior. Only the keys you pass are changed; pass `undefined` to reset a key.
+ * Returns the resulting configuration.
+ */
+declare function configure(config: GlobalConfig): Readonly<GlobalConfig>;
+/** Forget which deprecations were already reported, so `once` warnings show again. */
+declare function resetDeprecations(): void;
+/** Thrown in `throw` mode. */
+declare class DeprecationError extends Error {
+    readonly code?: string;
+    readonly event: DeprecationEvent;
+    constructor(event: DeprecationEvent);
+}
+/**
+ * Wrap a function or class so every call (or `new`) reports a deprecation.
+ * The wrapper keeps `this`, `new`, `name`, `length`, `prototype` and static members.
+ */
+declare function deprecate<T extends AnyFunction | (abstract new (...args: any[]) => any)>(fn: T, options?: DeprecationOptions): T;
+/**
+ * Return a proxy of `obj` whose given methods report a deprecation when they are **called**
+ * (reading the property, `typeof`, spreading or logging the object does not warn).
+ * Deprecated methods run against the original object, so calls they make through `this`
+ * are not reported again and private class fields keep working.
+ */
+declare function deprecateMethod<T extends object>(obj: T, methods: keyof T | readonly (keyof T)[], options?: DeprecationOptions): T;
+/**
+ * Redefine `obj[property]` in place so reading or writing it reports a deprecation.
+ * Works with data properties and getters/setters. Returns the same object.
+ */
+declare function deprecateProperty<T extends object>(obj: T, property: keyof T, options?: DeprecationOptions): T;
+
+/**
+ * Decorator that reports a deprecation when a class is instantiated, or when a method,
+ * getter, setter or `accessor` field is used.
+ *
+ * Works with standard (TC39, TypeScript 5+) decorators and with legacy
+ * `experimentalDecorators` (Angular, NestJS...).
+ *
+ * @example
+ * class Api {
+ *   \@Deprecated({ since: '1.2.0', replacement: 'Api.getUsersV2()' })
+ *   getUsers() {}
+ * }
+ */
+declare function Deprecated(options?: DeprecationOptions): any;
+
+/** Options accepted by the v0.x default export. */
+interface LegacyConfig extends DeprecationOptions {
+    /** Name of the method to deprecate when the first argument is an object. */
+    method?: string;
+}
+/**
+ * v0.x API, kept so existing code keeps working.
+ * @deprecated Use `deprecate(fn, options)` or `deprecateMethod(obj, 'method', options)`.
+ */
+declare function deprecated<T extends object>(obj: T, config?: LegacyConfig): T;
+
+export { Deprecated, DeprecationError, configure, deprecated as default, deprecate, deprecateMethod, deprecateProperty, resetDeprecations };
+export type { DeprecationEvent, DeprecationMode, DeprecationOptions, GlobalConfig, LegacyConfig, Logger };

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+/** How deprecations are surfaced. */
+type DeprecationMode = 'warn' | 'throw' | 'silent';
+/** Anything with a `warn` method (console, pino, winston, a custom logger...). */
+interface Logger {
+    warn: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+}
+/** Metadata describing a single deprecated API. */
+interface DeprecationOptions {
+    /** Human readable name of the deprecated API. Defaults to the function/property name. */
+    name?: string;
+    /** Full custom message. When omitted, a message is built from the other fields. */
+    message?: string;
+    /** Version (or date) in which the API was deprecated, e.g. `"1.4.0"`. */
+    since?: string;
+    /**
+     * Version or date in which the API will be removed, e.g. `"2.0.0"`, `"2027-01-01"` or a `Date`.
+     * When it is a date that already passed, the deprecation is flagged as overdue.
+     */
+    removeIn?: string | Date;
+    /** What to use instead, e.g. `"getUsersV2()"`. */
+    replacement?: string;
+    /** Stable identifier, e.g. `"MYLIB_DEP001"`. Used for dedupe and shown in Node warnings. */
+    code?: string;
+    /** Link to the migration guide. */
+    url?: string;
+    /** Warn only once per call site (default: global `once`, which defaults to `true`). */
+    once?: boolean;
+    /** Per-API logger. When set, it is used instead of `process.emitWarning`/`console.warn`. */
+    logger?: Logger;
+    /** Per-API telemetry hook, called in addition to the global `onDeprecation`. */
+    onDeprecation?: (event: DeprecationEvent) => void;
+    /**
+     * @deprecated Use `onDeprecation` instead. Kept for compatibility with v0.x.
+     */
+    sendMetrics?: (event: DeprecationEvent) => void;
+}
+/** Payload delivered to `onDeprecation` hooks. */
+interface DeprecationEvent {
+    name: string;
+    message: string;
+    code?: string;
+    since?: string;
+    removeIn?: string;
+    replacement?: string;
+    url?: string;
+    /** `true` when `removeIn` is a date that already passed. */
+    overdue: boolean;
+    /** First stack frame outside this library (best effort, `undefined` when unavailable). */
+    callSite?: string;
+    /** Stack trace starting at the caller (best effort). */
+    stack?: string;
+    /** Mode that was applied to this event. */
+    mode: DeprecationMode;
+}
+/** Global configuration, set with `configure()`. */
+interface GlobalConfig {
+    /**
+     * `warn` (default), `throw` or `silent`. When not set, it is read from the
+     * `IS_DEPRECATED_MODE` env var, then from Node's `--no-deprecation` / `--throw-deprecation`.
+     */
+    mode?: DeprecationMode;
+    /** Warn only once per API and call site. Default `true`. */
+    once?: boolean;
+    /** Global logger. Default: `process.emitWarning` in Node, `console.warn` elsewhere. */
+    logger?: Logger;
+    /** Global telemetry hook. Called even in `silent` mode. */
+    onDeprecation?: (event: DeprecationEvent) => void;
+}
+
+type AnyFunction = (...args: any[]) => any;
+/**
+ * Set global behavior. Only the keys you pass are changed; pass `undefined` to reset a key.
+ * Returns the resulting configuration.
+ */
+declare function configure(config: GlobalConfig): Readonly<GlobalConfig>;
+/** Forget which deprecations were already reported, so `once` warnings show again. */
+declare function resetDeprecations(): void;
+/** Thrown in `throw` mode. */
+declare class DeprecationError extends Error {
+    readonly code?: string;
+    readonly event: DeprecationEvent;
+    constructor(event: DeprecationEvent);
+}
+/**
+ * Wrap a function or class so every call (or `new`) reports a deprecation.
+ * The wrapper keeps `this`, `new`, `name`, `length`, `prototype` and static members.
+ */
+declare function deprecate<T extends AnyFunction | (abstract new (...args: any[]) => any)>(fn: T, options?: DeprecationOptions): T;
+/**
+ * Return a proxy of `obj` whose given methods report a deprecation when they are **called**
+ * (reading the property, `typeof`, spreading or logging the object does not warn).
+ * Deprecated methods run against the original object, so calls they make through `this`
+ * are not reported again and private class fields keep working.
+ */
+declare function deprecateMethod<T extends object>(obj: T, methods: keyof T | readonly (keyof T)[], options?: DeprecationOptions): T;
+/**
+ * Redefine `obj[property]` in place so reading or writing it reports a deprecation.
+ * Works with data properties and getters/setters. Returns the same object.
+ */
+declare function deprecateProperty<T extends object>(obj: T, property: keyof T, options?: DeprecationOptions): T;
+
+/**
+ * Decorator that reports a deprecation when a class is instantiated, or when a method,
+ * getter, setter or `accessor` field is used.
+ *
+ * Works with standard (TC39, TypeScript 5+) decorators and with legacy
+ * `experimentalDecorators` (Angular, NestJS...).
+ *
+ * @example
+ * class Api {
+ *   \@Deprecated({ since: '1.2.0', replacement: 'Api.getUsersV2()' })
+ *   getUsers() {}
+ * }
+ */
+declare function Deprecated(options?: DeprecationOptions): any;
+
+/** Options accepted by the v0.x default export. */
+interface LegacyConfig extends DeprecationOptions {
+    /** Name of the method to deprecate when the first argument is an object. */
+    method?: string;
+}
+/**
+ * v0.x API, kept so existing code keeps working.
+ * @deprecated Use `deprecate(fn, options)` or `deprecateMethod(obj, 'method', options)`.
+ */
+declare function deprecated<T extends object>(obj: T, config?: LegacyConfig): T;
+
+export { Deprecated, DeprecationError, configure, deprecated as default, deprecate, deprecateMethod, deprecateProperty, resetDeprecations };
+export type { DeprecationEvent, DeprecationMode, DeprecationOptions, GlobalConfig, LegacyConfig, Logger };

package/dist/index.js

@@ -0,0 +1,336 @@
+// src/env.ts
+function getProcess() {
+  const proc = globalThis.process;
+  return proc && typeof proc === "object" ? proc : void 0;
+}
+var MODES = ["warn", "throw", "silent"];
+function modeFromEnvironment() {
+  const proc = getProcess();
+  let fromEnv;
+  try {
+    fromEnv = proc?.env?.IS_DEPRECATED_MODE;
+  } catch {
+  }
+  const normalized = fromEnv?.trim().toLowerCase();
+  if (normalized && MODES.includes(normalized)) return normalized;
+  if (proc?.noDeprecation) return "silent";
+  if (proc?.throwDeprecation) return "throw";
+  return "warn";
+}
+function nodeEmitWarning() {
+  const emit = getProcess()?.emitWarning;
+  return typeof emit === "function" ? emit.bind(getProcess()) : void 0;
+}
+
+// src/core.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@mtorre4580/is-deprecated");
+var store = globalThis;
+var state = store[STATE_KEY] ?? (store[STATE_KEY] = { config: {}, seen: /* @__PURE__ */ new Set() });
+function configure(config) {
+  Object.assign(state.config, config);
+  return { ...state.config };
+}
+function resetDeprecations() {
+  state.seen.clear();
+}
+var DeprecationError = class extends Error {
+  constructor(event) {
+    super(event.message);
+    this.name = "DeprecationError";
+    this.code = event.code;
+    this.event = event;
+  }
+};
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}/;
+function parseRemoval(removeIn) {
+  if (removeIn instanceof Date) {
+    return Number.isNaN(removeIn.getTime()) ? {} : { label: removeIn.toISOString().slice(0, 10), date: removeIn };
+  }
+  if (typeof removeIn !== "string" || removeIn === "") return {};
+  if (ISO_DATE.test(removeIn)) {
+    const date = new Date(removeIn);
+    if (!Number.isNaN(date.getTime())) return { label: removeIn, date };
+  }
+  return { label: removeIn };
+}
+function buildMessage(options, name, removal, overdue) {
+  let message = options.message;
+  if (message === void 0) {
+    message = `${name} is deprecated`;
+    if (options.since) message += ` since ${options.since}`;
+    if (removal.label) {
+      if (overdue) message += ` and was scheduled for removal on ${removal.label}`;
+      else message += ` and will be removed ${removal.date ? "on" : "in"} ${removal.label}`;
+    }
+    message += ".";
+    if (options.replacement) message += ` Use ${options.replacement} instead.`;
+    if (options.url) message += ` See ${options.url}`;
+  }
+  return overdue ? `[OVERDUE] ${message}` : message;
+}
+function captureCallSite(boundary) {
+  const E = Error;
+  const holder = {};
+  const previousLimit = E.stackTraceLimit;
+  let skip = 0;
+  try {
+    if (typeof previousLimit === "number") E.stackTraceLimit = 10;
+    if (typeof E.captureStackTrace === "function") {
+      E.captureStackTrace(holder, boundary);
+    } else {
+      holder.stack = new Error().stack;
+      skip = 3;
+    }
+    void holder.stack;
+  } catch {
+    return {};
+  } finally {
+    if (typeof previousLimit === "number") E.stackTraceLimit = previousLimit;
+  }
+  if (typeof holder.stack !== "string") return {};
+  const frames = holder.stack.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !/^Error\b/.test(line)).slice(skip);
+  if (frames.length === 0) return {};
+  return {
+    callSite: frames[0].replace(/^at\s+/, ""),
+    stack: frames.join("\n")
+  };
+}
+function safeCall(hook, event) {
+  if (typeof hook !== "function") return;
+  try {
+    hook(event);
+  } catch {
+  }
+}
+function notify(options, fallbackName, boundary) {
+  const { config } = state;
+  const mode = config.mode ?? modeFromEnvironment();
+  const name = options.name ?? fallbackName;
+  const { callSite, stack } = captureCallSite(boundary);
+  if (mode !== "throw" && (options.once ?? config.once ?? true)) {
+    const key = `${options.code ?? ""}|${name}|${callSite ?? ""}`;
+    if (state.seen.has(key)) return;
+    state.seen.add(key);
+  }
+  const removal = parseRemoval(options.removeIn);
+  const overdue = removal.date !== void 0 && removal.date.getTime() <= Date.now();
+  const message = buildMessage(options, name, removal, overdue);
+  const event = {
+    name,
+    message,
+    code: options.code,
+    since: options.since,
+    removeIn: removal.label,
+    replacement: options.replacement,
+    url: options.url,
+    overdue,
+    callSite,
+    stack,
+    mode
+  };
+  safeCall(config.onDeprecation, event);
+  safeCall(options.onDeprecation, event);
+  safeCall(options.sendMetrics, event);
+  if (mode === "silent") return;
+  if (mode === "throw") throw new DeprecationError(event);
+  const logger = options.logger ?? config.logger;
+  if (logger) {
+    if (overdue && typeof logger.error === "function") logger.error(message);
+    else logger.warn(message);
+    return;
+  }
+  const emitWarning = nodeEmitWarning();
+  if (emitWarning) {
+    emitWarning(message, {
+      type: "DeprecationWarning",
+      code: options.code,
+      detail: callSite ? `Called from ${callSite}` : void 0
+    });
+    return;
+  }
+  if (typeof console !== "undefined") {
+    console.warn(`DeprecationWarning: ${message}${callSite ? `
+    at ${callSite}` : ""}`);
+  }
+}
+function copyFunctionShape(target, source) {
+  for (const key of ["name", "length"]) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (descriptor) Object.defineProperty(target, key, { ...descriptor, configurable: true });
+  }
+}
+function deprecate(fn, options = {}) {
+  if (typeof fn !== "function") {
+    throw new TypeError("deprecate() expects a function or class as first argument");
+  }
+  const fallbackName = fn.name || "anonymous function";
+  const handler = {
+    apply(target, thisArg, args) {
+      notify(options, fallbackName, handler.apply);
+      return Reflect.apply(target, thisArg, args);
+    },
+    construct(target, args, newTarget) {
+      notify(options, fallbackName, handler.construct);
+      return Reflect.construct(target, args, newTarget);
+    }
+  };
+  return new Proxy(fn, handler);
+}
+function deprecateMethod(obj, methods, options = {}) {
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError("deprecateMethod() expects an object as first argument");
+  }
+  const keys = Array.isArray(methods) ? methods : [methods];
+  if (keys.length === 0) throw new TypeError("deprecateMethod() expects at least one method name");
+  for (const key of keys) {
+    if (typeof obj[key] !== "function") {
+      throw new TypeError(`"${String(key)}" is not a method of the given object`);
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const proxy = new Proxy(obj, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function" || !keys.includes(property)) return value;
+      const original = value;
+      const cached = cache.get(property);
+      if (cached && cached.original === original) return cached.wrapped;
+      const methodOptions = keys.length === 1 ? options : { ...options, name: void 0 };
+      const wrapped = function deprecatedMethod(...args) {
+        notify(methodOptions, String(property), wrapped);
+        return Reflect.apply(original, this === proxy ? target : this, args);
+      };
+      copyFunctionShape(wrapped, original);
+      cache.set(property, { original, wrapped });
+      return wrapped;
+    }
+  });
+  return proxy;
+}
+function deprecateProperty(obj, property, options = {}) {
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    throw new TypeError("deprecateProperty() expects an object as first argument");
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(obj, property);
+  if (!descriptor) throw new TypeError(`"${String(property)}" is not an own property of the given object`);
+  if (!descriptor.configurable) throw new TypeError(`"${String(property)}" is not configurable`);
+  const name = options.name ?? String(property);
+  const next = { configurable: true, enumerable: descriptor.enumerable };
+  if ("value" in descriptor || "writable" in descriptor) {
+    let current = descriptor.value;
+    next.get = function get() {
+      notify(options, name, get);
+      return current;
+    };
+    if (descriptor.writable) {
+      next.set = function set(value) {
+        notify(options, name, set);
+        current = value;
+      };
+    }
+  } else {
+    const { get: originalGet, set: originalSet } = descriptor;
+    if (originalGet) {
+      next.get = function get() {
+        notify(options, name, get);
+        return originalGet.call(this);
+      };
+    }
+    if (originalSet) {
+      next.set = function set(value) {
+        notify(options, name, set);
+        originalSet.call(this, value);
+      };
+    }
+  }
+  Object.defineProperty(obj, property, next);
+  return obj;
+}
+
+// src/decorator.ts
+function isStandardContext(context) {
+  return typeof context === "object" && context !== null && "kind" in context;
+}
+function ownerName(instanceOrClass, isStatic) {
+  try {
+    const owner = isStatic ? instanceOrClass : instanceOrClass?.constructor;
+    return typeof owner?.name === "string" && owner.name !== "" ? owner.name : "Object";
+  } catch {
+    return "Object";
+  }
+}
+function wrapCallable(original, member, isStatic, suffix, options) {
+  const wrapped = function(...args) {
+    notify(options, `${ownerName(this, isStatic)}.${member}${suffix}`, wrapped);
+    return original.apply(this, args);
+  };
+  Object.defineProperty(wrapped, "name", { value: original.name, configurable: true });
+  return wrapped;
+}
+function fieldError() {
+  return new TypeError(
+    "@Deprecated() cannot intercept plain class fields: use an `accessor` field or a getter/setter"
+  );
+}
+function decorateStandard(value, context, options) {
+  const member = String(context.name);
+  const isStatic = Boolean(context.static);
+  switch (context.kind) {
+    case "class":
+      return deprecate(value, { ...options, name: options.name ?? (member || value.name) });
+    case "method":
+      return wrapCallable(value, member, isStatic, "()", options);
+    case "getter":
+    case "setter":
+      return wrapCallable(value, member, isStatic, "", options);
+    case "accessor": {
+      const get = function() {
+        notify(options, `${ownerName(this, isStatic)}.${member}`, get);
+        return value.get.call(this);
+      };
+      const set = function(next) {
+        notify(options, `${ownerName(this, isStatic)}.${member}`, set);
+        value.set.call(this, next);
+      };
+      return { get, set, init: (initial) => initial };
+    }
+    default:
+      throw fieldError();
+  }
+}
+function decorateLegacy(target, key, descriptor, options) {
+  if (key === void 0 && typeof target === "function") {
+    return deprecate(target, { ...options, name: options.name ?? target.name });
+  }
+  if (!descriptor) throw fieldError();
+  const member = String(key);
+  const isStatic = typeof target === "function";
+  const next = { ...descriptor };
+  if (typeof descriptor.value === "function") {
+    next.value = wrapCallable(descriptor.value, member, isStatic, "()", options);
+  }
+  if (descriptor.get) next.get = wrapCallable(descriptor.get, member, isStatic, "", options);
+  if (descriptor.set) next.set = wrapCallable(descriptor.set, member, isStatic, "", options);
+  return next;
+}
+function Deprecated(options = {}) {
+  return function deprecatedDecorator(value, context, descriptor) {
+    if (isStandardContext(context)) return decorateStandard(value, context, options);
+    return decorateLegacy(value, context, descriptor, options);
+  };
+}
+
+// src/index.ts
+function deprecated(obj, config = {}) {
+  if (obj == null) throw new TypeError("The param obj is required");
+  const { method, ...options } = config;
+  if (typeof obj === "function" && method === void 0) {
+    return deprecate(obj, options);
+  }
+  if (method === void 0 || typeof obj[method] !== "function") {
+    throw new TypeError("The object not have the method defined");
+  }
+  return deprecateMethod(obj, method, options);
+}
+
+export { Deprecated, DeprecationError, configure, deprecated as default, deprecate, deprecateMethod, deprecateProperty, resetDeprecations };

package/package.json

@@ -1,62 +1,95 @@
 {
   "name": "@mtorre4580/is-deprecated",
-  "version": "0.0.2",
-  "description": "Library to deprecated properties and methods in objects or functions",
+  "version": "1.0.0",
+  "description": "Runtime deprecation warnings for functions, methods, properties and classes: Node + browser, TypeScript, decorators, telemetry hooks and warn/throw/silent modes",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mtorre4580/is-deprecated"
+    "url": "git+https://github.com/mtorre4580/is-deprecated.git"
   },
-  "homepage": "https://github.com/mtorre4580/is-deprecated/blob/main/README.md",
+  "homepage": "https://github.com/mtorre4580/is-deprecated#readme",
   "bugs": {
     "url": "https://github.com/mtorre4580/is-deprecated/issues"
   },
   "keywords": [
     "deprecated",
-    "javascript",
-    "nodejs",
-    "functions",
-    "methods",
-    "utility"
+    "deprecate",
+    "deprecation",
+    "depd",
+    "warning",
+    "decorator",
+    "typescript",
+    "browser",
+    "nodejs"
   ],
   "author": "mtorre4580",
+  "type": "module",
   "files": [
     "dist"
   ],
-  "main": "./dist/is-deprecated.umd.js",
-  "module": "./dist/is-deprecated.es.js",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "import": "./dist/is-deprecated.es.js",
-      "require": "./dist/is-deprecated.umd.js"
-    }
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "prepare": "husky install",
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview",
-    "lint": "eslint '**/*.js'",
-    "lint:fix": "eslint '**/*.js' --fix",
-    "test": "jest --config jest.config.js",
-    "test:coverage": "jest --config jest.config.js --coverage",
-    "test:ci": "node --expose-gc ./node_modules/.bin/jest --ci --bail --runInBand --logHeapUsage --coverage",
-    "update-changelog": "git fetch && auto-changelog",
-    "audit": "yarn audit --groups 'dependencies devDependencies'"
+    "prepare": "husky",
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check:package": "publint && attw --pack . --profile node16",
+    "size": "size-limit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build && npm run check:package",
+    "update-changelog": "git fetch && auto-changelog"
   },
   "devDependencies": {
-    "@commitlint/cli": "^18.4.3",
-    "@commitlint/config-conventional": "^18.4.3",
-    "@types/jest": "^29.5.11",
-    "@types/node": "^20.10.4",
-    "auto-changelog": "^2.4.0",
-    "eslint": "^8.56.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.29.1",
-    "husky": "^8.0.3",
-    "jest": "^29.7.0",
-    "vite": "^5.0.10"
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@commitlint/cli": "^21.2.4",
+    "@commitlint/config-conventional": "^21.2.4",
+    "@eslint/js": "^10.0.1",
+    "@size-limit/preset-small-lib": "^14.3.0",
+    "@types/node": "^24.0.0",
+    "@vitest/coverage-v8": "^5.1.0",
+    "auto-changelog": "^2.5.0",
+    "eslint": "^10.15.0",
+    "happy-dom": "^21.0.4",
+    "husky": "^9.1.7",
+    "publint": "^0.3.25",
+    "size-limit": "^14.3.0",
+    "tsup": "^9.0.0",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.72.2",
+    "vitest": "^5.1.0"
   },
+  "size-limit": [
+    {
+      "name": "full bundle (ESM, gzip)",
+      "path": "dist/index.js",
+      "limit": "2.5 kB"
+    },
+    {
+      "name": "deprecate() only",
+      "path": "dist/index.js",
+      "import": "{ deprecate }",
+      "limit": "1.5 kB"
+    }
+  ],
   "auto-changelog": {
     "output": "CHANGELOG.md",
     "template": "update-changelog.hbs",
@@ -67,6 +100,10 @@
     "hideEmptyReleases": true
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }

package/dist/is-deprecated.es.js

@@ -1,28 +0,0 @@
-var f = (e, r) => () => (r || e((r = { exports: {} }).exports, r), r.exports);
-var h = f((w, c) => {
-  function u(e) {
-    return typeof e == "function";
-  }
-  function a(e, r) {
-    const {
-      method: n = null,
-      message: t = "This will be deprecated soon",
-      logger: o = console,
-      sendMetrics: i = () => {
-      }
-    } = r || {};
-    if (e == null)
-      throw new Error("The param obj is required");
-    if (u(e))
-      return o.warn(t), i(), (...s) => e(...s);
-    if (!u(e[n]))
-      throw new Error("The object not have the method defined");
-    return new Proxy(e, {
-      get(s, d) {
-        return d === n && (o.warn(t), i()), Reflect.get(...arguments);
-      }
-    });
-  }
-  c.exports = a;
-});
-export default h();

package/dist/is-deprecated.umd.js

@@ -1 +0,0 @@
-(function(n){typeof define=="function"&&define.amd?define(n):n()})(function(){"use strict";function n(e){return typeof e=="function"}function f(e,d){const{method:t=null,message:r="This will be deprecated soon",logger:i=console,sendMetrics:o=()=>{}}=d||{};if(e==null)throw new Error("The param obj is required");if(n(e))return i.warn(r),o(),(...u)=>e(...u);if(!n(e[t]))throw new Error("The object not have the method defined");return new Proxy(e,{get(u,c){return c===t&&(i.warn(r),o()),Reflect.get(...arguments)}})}module.exports=f});