rtt 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nizami
+
+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,54 @@
+# rtt
+
+Runtime Typescript Types
+
+## Overview
+
+This package provides a way to store type information in objects and check types at runtime in TypeScript. It is useful for scenarios where you need runtime type introspection, such as serialization, validation, or building type-safe APIs.
+
+## Features
+
+- Attach type metadata to objects.
+- Check if an object is of a specific type at runtime using the `is` function.
+- Support for type hierarchies and generics.
+
+## Installation
+
+```sh
+npm install rtt
+```
+
+## Usage
+
+```typescript
+import {$NewType, $type, is, Model} from 'rtt';
+
+// Define types
+const $A = () => $NewType('MyPackage', 'A');
+const $B = () => $NewType('MyPackage', 'B', $A());
+
+// Create a model instance
+const model: Model = {
+  [$type]: $B(),
+};
+
+// Runtime type checks
+is(model, $B()); // true
+is(model, $A()); // true (because B extends A)
+```
+
+## API
+
+### `$NewType(packageName: string, typeName: string, parent?, generics?)`
+
+Creates a new runtime type.
+
+### `is(model: any, type: $Type): boolean`
+
+Checks if the given model is of the specified type (or its parent).
+
+### `Model`
+
+Interface for objects with runtime type information.
+
+---

package/dist/brand.d.ts

@@ -0,0 +1,5 @@
+declare const brand: unique symbol;
+export type Brand<T extends `${string}.${string}`> = {
+    [brand]?: T;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './brand';
+export * from './is';
+export * from './model';
+export * from './type.factory';
+export * from './type';

package/dist/index.js

@@ -0,0 +1,38 @@
+function is(model, type) {
+  return model?.[$type]?.is(type) ?? false;
+}
+const $type = Symbol("type");
+const $Model = () => $NewType("RuntimeType", "Model");
+function $NewType(packageName, typeName, parent, generics) {
+  return {
+    packageName,
+    typeName,
+    parent,
+    generics,
+    toString() {
+      return `${this.packageName}.${this.typeName}`;
+    },
+    nameEquals(other) {
+      return this.typeName === other.typeName && this.packageName == other.packageName;
+    },
+    is(other) {
+      if (this.parent?.is(other) || other.nameEquals($Model())) {
+        return true;
+      }
+      if (other.generics && other.generics?.length > 0) {
+        if (this.generics && this.generics.length === other.generics.length) {
+          return this.generics.every((x, i) => x.is(other.generics[i]));
+        }
+        return false;
+      }
+      return this.nameEquals(other);
+    }
+  };
+}
+export {
+  $Model,
+  $NewType,
+  $type,
+  is
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/is.ts","../src/model.ts","../src/type.factory.ts"],"sourcesContent":["import {$Type, $type} from '#lib';\n\nexport function is<T extends $Type>(model: any, type: T): model is Exclude<T['type'], undefined> {\n  return (model?.[$type] as $Type)?.is(type) ?? false;\n}\n","import { $Type, $NewType } from \"#lib\";\n\nexport const $type = Symbol('type');\n\nexport interface Model {\n  [$type]: $Type;\n}\n\nexport const $Model = () => $NewType<Model>('RuntimeType', 'Model');\n","import {$Model, $Type, Model} from '#lib';\n\nexport function $NewType<T extends Model>(\n  packageName: string,\n  typeName: string,\n  parent?: $Type | null | undefined,\n  generics?: $Type[] | null | undefined,\n): $Type<T> {\n  return {\n    packageName,\n    typeName,\n    parent,\n    generics,\n\n    toString(): string {\n      return `${this.packageName}.${this.typeName}`;\n    },\n\n    nameEquals(other: $Type): boolean {\n      return this.typeName === other.typeName && this.packageName == other.packageName;\n    },\n\n    is(other: $Type): boolean {\n      if (this.parent?.is(other) || other.nameEquals($Model())) {\n        return true;\n      }\n\n      if (other.generics && other.generics?.length > 0) {\n        if (this.generics && this.generics.length === other.generics.length) {\n          // todo Covariance and contravariance ???\n          return this.generics.every((x, i) => x.is(other.generics![i]));\n        }\n\n        return false;\n      }\n\n      return this.nameEquals(other);\n    },\n  };\n}\n"],"names":[],"mappings":"AAEO,SAAS,GAAoB,OAAY,MAAiD;AAC/F,SAAQ,QAAQ,KAAK,GAAa,GAAG,IAAI,KAAK;AAChD;ACFO,MAAM,QAAQ,OAAO,MAAM;AAM3B,MAAM,SAAS,MAAM,SAAgB,eAAe,OAAO;ACN3D,SAAS,SACd,aACA,UACA,QACA,UACU;AACV,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IAEA,WAAmB;AACjB,aAAO,GAAG,KAAK,WAAW,IAAI,KAAK,QAAQ;AAAA,IAC7C;AAAA,IAEA,WAAW,OAAuB;AAChC,aAAO,KAAK,aAAa,MAAM,YAAY,KAAK,eAAe,MAAM;AAAA,IACvE;AAAA,IAEA,GAAG,OAAuB;AACxB,UAAI,KAAK,QAAQ,GAAG,KAAK,KAAK,MAAM,WAAW,OAAA,CAAQ,GAAG;AACxD,eAAO;AAAA,MACT;AAEA,UAAI,MAAM,YAAY,MAAM,UAAU,SAAS,GAAG;AAChD,YAAI,KAAK,YAAY,KAAK,SAAS,WAAW,MAAM,SAAS,QAAQ;AAEnE,iBAAO,KAAK,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,SAAU,CAAC,CAAC,CAAC;AAAA,QAC/D;AAEA,eAAO;AAAA,MACT;AAEA,aAAO,KAAK,WAAW,KAAK;AAAA,IAC9B;AAAA,EAAA;AAEJ;"}

package/dist/is.d.ts

@@ -0,0 +1,2 @@
+import { $Type } from './index.ts';
+export declare function is<T extends $Type>(model: any, type: T): model is Exclude<T['type'], undefined>;

package/dist/model.d.ts

@@ -0,0 +1,6 @@
+import { $Type } from './index.ts';
+export declare const $type: unique symbol;
+export interface Model {
+    [$type]: $Type;
+}
+export declare const $Model: () => $Type<Model>;

package/dist/type.d.ts

@@ -0,0 +1,10 @@
+export interface $Type<T = unknown> {
+    packageName: string;
+    typeName: string;
+    type?: T;
+    parent?: $Type | null | undefined;
+    generics?: $Type[] | null | undefined;
+    toString(): string;
+    nameEquals(other: $Type): boolean;
+    is(other: $Type): boolean;
+}

package/dist/type.factory.d.ts

@@ -0,0 +1,2 @@
+import { $Type, Model } from './index.ts';
+export declare function $NewType<T extends Model>(packageName: string, typeName: string, parent?: $Type | null | undefined, generics?: $Type[] | null | undefined): $Type<T>;

package/dist/type.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "rtt",
+  "version": "1.0.0",
+  "description": "Runtime Typescript Types",
+  "main": "index.js",
+  "scripts": {
+    "build": "barrelize && vite build",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nizami/rtt.git"
+  },
+  "keywords": [
+    "Typescript",
+    "Runtime Types"
+  ],
+  "author": "Nizami",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nizami/rtt/issues"
+  },
+  "homepage": "https://github.com/nizami/rtt#readme",
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "barrelize": "^1.6.2",
+    "typescript": "~5.8.3",
+    "vite": "^7.0.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  }
+}