@danielsimonjr/mathts-typed-function 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+export { TypedFunction, create, default as typed } from 'typed-function';
+
+/**
+ * @danielsimonjr/mathts-typed-function
+ *
+ * Utility helpers for typed-function integration in MathTS.
+ * This package provides type test functions and signature utilities.
+ *
+ * NOTE: For creating typed functions, use typed-function directly:
+ * ```typescript
+ * import typed, { create } from 'typed-function';
+ * ```
+ *
+ * Or use @danielsimonjr/mathts-core which provides mathTyped pre-configured with MathTS types:
+ * ```typescript
+ * import { mathTyped } from '@danielsimonjr/mathts-core';
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Type definition for typed-function
+ */
+interface TypeDef {
+    name: string;
+    test: (x: unknown) => boolean;
+}
+/**
+ * Conversion definition for typed-function
+ */
+interface ConversionDef {
+    from: string;
+    to: string;
+    convert: (value: unknown) => unknown;
+}
+/**
+ * Signature map for typed functions
+ */
+type SignatureMap<T = unknown> = {
+    [signature: string]: (...args: unknown[]) => T;
+};
+/**
+ * Type test function
+ */
+type TypeTest<T> = (x: unknown) => x is T;
+/**
+ * Type conversion function
+ */
+type TypeConverter<From, To> = (value: From) => To;
+declare const isNumber: (x: unknown) => x is number;
+declare const isBoolean: (x: unknown) => x is boolean;
+declare const isString: (x: unknown) => x is string;
+declare const isBigInt: (x: unknown) => x is bigint;
+declare const isArray: (x: unknown) => x is unknown[];
+declare const isFunction: (x: unknown) => x is (...args: unknown[]) => unknown;
+declare const isObject: (x: unknown) => x is object;
+declare const isNull: (x: unknown) => x is null;
+declare const isUndefined: (x: unknown) => x is undefined;
+declare const isNullOrUndefined: (x: unknown) => x is null | undefined;
+declare const isFiniteNumber: (x: unknown) => x is number;
+declare const isInteger: (x: unknown) => x is number;
+declare const isPositiveInteger: (x: unknown) => x is number;
+declare const isNonNegativeInteger: (x: unknown) => x is number;
+declare const isNaN: (x: unknown) => x is number;
+declare const isTypedArray: (x: unknown) => x is ArrayBufferView;
+declare const isFloat64Array: (x: unknown) => x is Float64Array;
+declare const isFloat32Array: (x: unknown) => x is Float32Array;
+declare const isInt32Array: (x: unknown) => x is Int32Array;
+declare const isUint32Array: (x: unknown) => x is Uint32Array;
+declare const isArrayBuffer: (x: unknown) => x is ArrayBuffer;
+/**
+ * Parse a signature string into component types
+ *
+ * @param signature - Signature string (e.g., "number, number")
+ * @returns Array of type names
+ */
+declare function parseSignature(signature: string): string[];
+/**
+ * Build a signature string from type names
+ *
+ * @param types - Array of type names
+ * @returns Signature string
+ */
+declare function buildSignature(...types: string[]): string;
+/**
+ * Error thrown when no matching signature is found
+ */
+declare class NoMatchingSignatureError extends Error {
+    readonly functionName: string;
+    readonly actualTypes: string[];
+    readonly availableSignatures: string[];
+    constructor(functionName: string, actualTypes: string[], availableSignatures: string[]);
+}
+/**
+ * Error thrown when type conversion fails
+ */
+declare class TypeConversionError extends Error {
+    readonly fromType: string;
+    readonly toType: string;
+    readonly originalError?: Error | undefined;
+    constructor(fromType: string, toType: string, originalError?: Error | undefined);
+}
+
+export { type ConversionDef, NoMatchingSignatureError, type SignatureMap, TypeConversionError, type TypeConverter, type TypeDef, type TypeTest, buildSignature, isArray, isArrayBuffer, isBigInt, isBoolean, isFiniteNumber, isFloat32Array, isFloat64Array, isFunction, isInt32Array, isInteger, isNaN, isNonNegativeInteger, isNull, isNullOrUndefined, isNumber, isObject, isPositiveInteger, isString, isTypedArray, isUint32Array, isUndefined, parseSignature };

package/dist/index.js

@@ -0,0 +1,80 @@
+// src/index.ts
+import { default as default2, create } from "typed-function";
+var isNumber = (x) => typeof x === "number";
+var isBoolean = (x) => typeof x === "boolean";
+var isString = (x) => typeof x === "string";
+var isBigInt = (x) => typeof x === "bigint";
+var isArray = (x) => Array.isArray(x);
+var isFunction = (x) => typeof x === "function";
+var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var isNull = (x) => x === null;
+var isUndefined = (x) => x === void 0;
+var isNullOrUndefined = (x) => x === null || x === void 0;
+var isFiniteNumber = (x) => typeof x === "number" && isFinite(x);
+var isInteger = (x) => typeof x === "number" && Number.isInteger(x);
+var isPositiveInteger = (x) => typeof x === "number" && Number.isInteger(x) && x > 0;
+var isNonNegativeInteger = (x) => typeof x === "number" && Number.isInteger(x) && x >= 0;
+var isNaN = (x) => typeof x === "number" && Number.isNaN(x);
+var isTypedArray = (x) => ArrayBuffer.isView(x) && !(x instanceof DataView);
+var isFloat64Array = (x) => x instanceof Float64Array;
+var isFloat32Array = (x) => x instanceof Float32Array;
+var isInt32Array = (x) => x instanceof Int32Array;
+var isUint32Array = (x) => x instanceof Uint32Array;
+var isArrayBuffer = (x) => x instanceof ArrayBuffer;
+function parseSignature(signature) {
+  return signature.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function buildSignature(...types) {
+  return types.join(", ");
+}
+var NoMatchingSignatureError = class extends Error {
+  constructor(functionName, actualTypes, availableSignatures) {
+    super(
+      `No matching signature found for ${functionName}(${actualTypes.join(", ")}). Available signatures: ${availableSignatures.join("; ")}`
+    );
+    this.functionName = functionName;
+    this.actualTypes = actualTypes;
+    this.availableSignatures = availableSignatures;
+    this.name = "NoMatchingSignatureError";
+  }
+};
+var TypeConversionError = class extends Error {
+  constructor(fromType, toType, originalError) {
+    super(
+      `Cannot convert from ${fromType} to ${toType}` + (originalError ? `: ${originalError.message}` : "")
+    );
+    this.fromType = fromType;
+    this.toType = toType;
+    this.originalError = originalError;
+    this.name = "TypeConversionError";
+  }
+};
+export {
+  NoMatchingSignatureError,
+  TypeConversionError,
+  buildSignature,
+  create,
+  isArray,
+  isArrayBuffer,
+  isBigInt,
+  isBoolean,
+  isFiniteNumber,
+  isFloat32Array,
+  isFloat64Array,
+  isFunction,
+  isInt32Array,
+  isInteger,
+  isNaN,
+  isNonNegativeInteger,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isObject,
+  isPositiveInteger,
+  isString,
+  isTypedArray,
+  isUint32Array,
+  isUndefined,
+  parseSignature,
+  default2 as typed
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@danielsimonjr/mathts-typed-function",
+  "version": "0.1.1",
+  "description": "Utility helpers for typed-function integration in MathTS",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "packages/typed-function"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "typed-function",
+    "polymorphism",
+    "type-dispatch"
+  ]
+}