@magmacomputing/tempo 1.0.0

package/dist/type.library.d.ts

@@ -0,0 +1,296 @@
+import { Tempo } from './tempo.class.js';
+import { Pledge } from './pledge.class.js';
+import type { Enum } from './enumerate.library.js';
+/**
+ * return an object's type as a ProperCase string.
+ * if instance, return Class name
+ */
+export declare const getType: (obj?: any, ...instances: Instance[]) => Type;
+/** return TypeValue<T> object */
+export declare const asType: <T>(value?: T, ...instances: Instance[]) => TypeValue<T>;
+/** assert value is one of a list of Types */
+export declare const isType: <T>(obj: unknown, ...types: Type[]) => obj is T;
+/** Type-Guards: assert \<obj> is of \<type> */
+export declare const isPrimitive: (obj?: unknown) => obj is Primitive;
+export declare const isReference: (obj?: unknown) => obj is Object;
+export declare const isIterable: <T>(obj: unknown) => obj is Iterable<T>;
+export declare const isString: <T>(obj?: T) => obj is Extract<T, string>;
+export declare const isNumber: <T>(obj?: T) => obj is Extract<T, number>;
+export declare const isInteger: <T>(obj?: T) => obj is Extract<T, bigint>;
+export declare const isIntegerLike: <T>(obj?: T) => obj is Extract<T, string>;
+export declare const isDigit: <T>(obj?: T) => obj is Extract<T, number | bigint>;
+export declare const isBoolean: <T>(obj?: T) => obj is Extract<T, boolean>;
+export declare const isArray: <T>(obj: unknown) => obj is T[];
+export declare const isArrayLike: <T>(obj: any) => obj is ArrayLike<T>;
+export declare const isObject: <T>(obj?: T) => obj is Extract<T, object>;
+export declare const isDate: <T>(obj?: T) => obj is Extract<T, Date>;
+export declare const isRegExp: <T>(obj?: T) => obj is Extract<T, RegExp>;
+export declare const isRegExpLike: <T>(obj?: T) => obj is Extract<T, string>;
+export declare const isSymbol: <T>(obj?: T) => obj is Extract<T, symbol>;
+export declare const isSymbolFor: <T>(obj?: T) => obj is Extract<T, symbol>;
+export declare const isPropertyKey: (obj?: unknown) => obj is PropertyKey;
+export declare const isNull: <T>(obj?: T) => obj is Extract<T, null>;
+export declare const isNullish: <T>(obj: T) => obj is Extract<T, Nullish>;
+export declare const isUndefined: <T>(obj?: T) => obj is undefined;
+export declare const isDefined: <T>(obj: T) => obj is NonNullable<T>;
+export declare const isClass: <T>(obj?: T) => obj is Extract<T, Function>;
+export declare const isFunction: (obj?: any) => obj is Function;
+export declare const isPromise: <T>(obj?: T) => obj is Extract<T, Promise<any>>;
+export declare const isMap: <K, V>(obj?: unknown) => obj is Map<K, V>;
+export declare const isSet: <K>(obj?: unknown) => obj is Set<K>;
+export declare const isError: (err: unknown) => err is Error;
+export declare const isTemporal: <T>(obj: T) => obj is Extract<T, Temporals>;
+export declare const isTempo: (obj: unknown) => obj is Tempo;
+export declare const isEnum: <E extends Property<any>>(obj: unknown) => obj is Enum.props<E>;
+export declare const isPledge: <P>(obj: unknown) => obj is Pledge<P>;
+export declare const nullToZero: <T>(obj: T) => 0 | NonNullable<T>;
+export declare const nullToEmpty: <T>(obj: T) => "" | NonNullable<T>;
+export declare const nullToValue: <T, R>(obj: T, value: R) => R | NonNullable<T>;
+/** object has no values */
+export declare const isEmpty: <T>(obj?: T) => boolean;
+export declare function assertCondition(condition: boolean, message?: string): asserts condition;
+export declare function assertString(str: unknown): asserts str is string;
+export declare function assertNever(val: never): asserts val is never;
+/** infer T of a <T | T[]> */ export type TValue<T> = T extends Array<infer A> ? A : NonNullable<T>;
+/** cast <T | undefined> as <T | T[]> */ export type TValues<T> = TValue<T> | Array<TValue<T>> | Extract<T, undefined>;
+/** cast <T | T[]> as T[] */ export type TArray<T> = Array<TValue<T>>;
+/** bottom value */ export type Nullish = null | undefined | void;
+/** Generic Record */ export type Property<T> = Record<PropertyKey, T>;
+/** Generic Record or Array */ export type Obj = Property<any> | Array<any>;
+export type WellKnownSymbols = {
+    [K in keyof SymbolConstructor]: SymbolConstructor[K] extends symbol ? SymbolConstructor[K] : never;
+}[keyof SymbolConstructor];
+type SafeCount<T, Acc extends any[] = [], Last = LastInUnion<T>> = Acc['length'] extends 1000 ? number : 0 extends (1 & T) ? number : [
+    T
+] extends [never] ? Acc['length'] : SafeCount<Exclude<T, Last>, [...Acc, any]>;
+/** Own properties of an Array, Object, Map or Enum */
+type IgnoreOf = WellKnownSymbols | Enum.methods;
+export type CountOf<T> = SafeCount<T>;
+export type OwnOf<T extends Obj> = T extends Array<any> ? {
+    [K in number]: T[number];
+} : Omit<T, IgnoreOf>;
+export type KeyOf<T extends Obj> = T extends Array<any> ? number : Exclude<Extract<keyof T, PropertyKey>, IgnoreOf>;
+export type ValueOf<T extends Obj> = T extends Array<any> ? T[number] : T[KeyOf<T>];
+export type EntryOf<T extends Obj> = [KeyOf<T>, ValueOf<T>];
+/** extracts only the Literal string keys (not index signatures) from an object/interface */
+export type LiteralKey<T> = {
+    [K in keyof T]: string extends K ? never : K;
+}[keyof T] & string;
+/** mark some fields as Optional */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** Remove 'optional' on keys as well as 'undefined' on values */
+export type NonOptional<T> = {
+    [K in keyof T]-?: Exclude<T[K], undefined>;
+};
+/** Record with only one-key */
+export type OneKey<K extends keyof any, V, KK extends keyof any = K> = {
+    [P in K]: {
+        [Q in P]: V;
+    } & {
+        [Q in Exclude<KK, P>]?: undefined;
+    } extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ParseInt<T> = T extends `${infer N extends number}` ? N : never;
+export type TPlural<T extends string> = `${T}s`;
+type toName<T extends Primitive> = T extends string ? "String" : T extends number ? "Number" : T extends bigint ? "BigInt" : T extends boolean ? "Boolean" : T extends symbol ? "Symbol" : T extends void ? "Void" : T extends undefined ? "Undefined" : T extends null ? "Null" : never;
+type Primitive = string | number | bigint | boolean | symbol | void | undefined | null;
+export type Primitives = toName<Primitive>;
+/** Generic constructor type */
+export type Constructor<T = any> = new (...args: any[]) => T;
+type Instance = {
+    type: string;
+    class: Function;
+};
+declare const Temporal: any;
+export type Temporals = typeof Temporal extends {
+    Now: any;
+} ? Exclude<keyof typeof Temporal, 'Now'> : never;
+export type Type = 'String' | 'Number' | 'BigInt' | 'Boolean' | 'Object' | 'Array' | 'ArrayLike' | 'Null' | 'Undefined' | 'Void' | 'Empty' | 'Date' | 'Function' | 'AsyncFunction' | 'Class' | 'Promise' | 'RegExp' | 'Blob' | 'Map' | 'Set' | 'WeakMap' | 'WeakSet' | 'WeakRef' | 'Symbol' | 'Error' | 'Temporal' | 'Temporal.Instant' | 'Temporal.ZonedDateTime' | 'Temporal.PlainDateTime' | 'Temporal.PlainDate' | 'Temporal.PlainTime' | 'Temporal.PlainYearMonth' | 'Temporal.PlainMonthDay' | 'Enumify' | 'Tempo' | 'Pledge';
+export type TypeValue<T> = {
+    type: 'String';
+    value: string;
+} | {
+    type: 'Number';
+    value: number;
+} | {
+    type: 'BigInt';
+    value: bigint;
+} | {
+    type: 'Boolean';
+    value: boolean;
+} | {
+    type: 'Object';
+    value: Extract<T, Property<unknown>>;
+} | {
+    type: 'Array';
+    value: Array<T>;
+} | {
+    type: 'ArrayLike';
+    value: ArrayLike<T>;
+} | {
+    type: 'Undefined';
+    value: undefined;
+} | {
+    type: 'Null';
+    value: null;
+} | {
+    type: 'Void';
+    value: void;
+} | {
+    type: 'Empty';
+    value: unknown;
+} | {
+    type: 'Date';
+    value: Date;
+} | {
+    type: 'Function';
+    value: Function;
+} | {
+    type: 'Class';
+    value: T;
+} | {
+    type: 'Promise';
+    value: Promise<T>;
+} | {
+    type: 'RegExp';
+    value: RegExp;
+} | {
+    type: 'Blob';
+    value: Blob;
+} | {
+    type: 'Map';
+    value: Map<any, T>;
+} | {
+    type: 'Set';
+    value: Set<T>;
+} | {
+    type: 'WeakSet';
+    value: WeakSet<Property<unknown>>;
+} | {
+    type: 'WeakMap';
+    value: WeakMap<Property<unknown>, T>;
+} | {
+    type: 'Symbol';
+    value: symbol;
+} | {
+    type: 'Error';
+    value: Error;
+} | {
+    type: 'Temporal';
+    value: Temporals;
+} | {
+    type: 'Temporal.Instant';
+    value: Temporal.Instant;
+} | {
+    type: 'Temporal.ZonedDateTime';
+    value: Temporal.ZonedDateTime;
+} | {
+    type: 'Temporal.PlainDateTime';
+    value: Temporal.PlainDateTime;
+} | {
+    type: 'Temporal.PlainDate';
+    value: Temporal.PlainDate;
+} | {
+    type: 'Temporal.PlainTime';
+    value: Temporal.PlainTime;
+} | {
+    type: 'Temporal.PlainYearMonth';
+    value: Temporal.PlainYearMonth;
+} | {
+    type: 'Temporal.PlainMonthDay';
+    value: Temporal.PlainMonthDay;
+} | {
+    type: 'Tempo';
+    value: Tempo;
+} | {
+    type: 'Pledge';
+    value: Pledge<T>;
+} | {
+    type: 'Enumify';
+    value: Enum.wrap<Property<any>>;
+};
+type TupleEntry<T extends readonly unknown[], I extends unknown[] = [], R = never> = T extends readonly [infer Head, ...infer Tail] ? TupleEntry<Tail, [...I, unknown], R | [`${I["length"]}`, Head]> : R;
+type ObjectEntry<T extends Property<any>> = T extends object ? {
+    [K in keyof T]: [T[K]] extends [never] ? never : [K, Required<T>[K]];
+}[keyof T] extends infer E ? E extends [infer K extends string | number, infer V] ? [`${K}`, V] : E extends [infer K extends symbol, infer V] ? [K, V] : never : never : never;
+/** if T extends readonly[] => [number, T],   if T extends {} => [key:string, T] */
+export type Entry<T extends Property<any>> = T extends readonly [unknown, ...unknown[]] ? TupleEntry<T> : T extends ReadonlyArray<infer U> ? [`${number}`, U] : ObjectEntry<T>;
+/** Object.entries<T> as [number,T][] */
+export type Entries<T extends Property<T>> = ReadonlyArray<Entry<T>>;
+/** invert key-value object */
+export type Inverse<T> = {
+    [K in keyof T as (T[K] & PropertyKey)]: K;
+};
+/** assign array indexes as values in an object */
+export type Index<T extends readonly any[]> = {
+    [K in Entry<T> as `${K[1]}`]: ParseInt<K[0]>;
+};
+/** reverse a Tuple */
+export type Reverse<T extends any[], R extends any[] = []> = ReturnType<T extends [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
+/** reverse a Record */
+export type Invert<T extends Record<keyof T, keyof any>> = {
+    [K in keyof T as T[K]]: K;
+};
+type EnumerateMin<N extends number, Acc extends number[] = []> = Acc["length"] extends N ? Acc[number] : EnumerateMin<N, [...Acc, Acc["length"]]>;
+type EnumerateMax<N extends number, Acc extends number[] = []> = Acc["length"] extends N ? ([...Acc, Acc["length"]])[number] : EnumerateMax<N, [...Acc, Acc["length"]]>;
+/** declare expected range of values */
+export type IntRange<Lower extends number, Upper extends number> = Exclude<EnumerateMax<Upper>, EnumerateMin<Lower>>;
+declare const __brand: unique symbol;
+type Brand<B> = {
+    [__brand]: B;
+};
+export type Branded<T, B> = T & Brand<B>;
+export type EmptyObject = {
+    [__brand]?: never;
+};
+type Length<T extends string, Count extends number[] = []> = T extends `${string}${infer Tail}` ? Length<Tail, [...Count, 0]> : Count["length"];
+type Compare<First extends number, Second extends number, Count extends number[] = []> = First extends Second ? 0 : Count["length"] extends First ? -1 : Count["length"] extends Second ? 1 : Compare<First, Second, [...Count, 0]>;
+export type MaxLength<T extends string, Max extends number> = Compare<Length<T>, Max> extends -1 | 0 ? T : never;
+export type MinLength<T extends string, Min extends number> = Compare<Min, Length<T>> extends -1 | 0 ? T : never;
+export type InRange<T extends string, Min extends number, Max extends number> = MinLength<T, Min> & MaxLength<T, Max>;
+/**
+ * return a substring of a string-type
+ * eg: Substr<Monday|Tuesday|Wednesday, 3> returns Mon|Tue|Wed
+ * U is the original string union
+ * Max is the number of chars to return
+ * Start is the offset (starting from '1')
+ */
+export type Substring<U extends string, Max extends number, Start extends number = 1> = Substr<U, Max, Start>;
+/**
+ * internal Type for Substring<> to recurse
+ * Str is the string to build and return
+ * Offset is an internal array used to assist with determining start-point of T
+ */
+type Substr<U, Max, Start, Str extends string = '', Offset extends number[] = [0]> = U extends `${infer NextChar}${infer Rest}` ? Offset["length"] extends Start ? Length<Str> extends Max ? Str : Substr<Rest, Start, Max, `${Str}${NextChar}`, Offset> : Substr<Rest, Start, Max, Str, [...Offset, 0]> : Str;
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+/**
+ * convert a Union to a Tuple.
+ * usage: UnionToTuple<A | B> = [A, B]
+ */
+export type UnionToTuple<T, Acc extends any[] = [], Last = LastInUnion<T>> = Acc['length'] extends 1000 ? T[] : [
+    T
+] extends [never] ? Acc : UnionToTuple<Exclude<T, Last>, [Last, ...Acc]>;
+/** Deep Readonly object for type safety */
+export type Secure<T> = T extends (infer R)[] ? SecureArray<R> : T extends Function ? T : T extends object ? SecureObject<T> : T;
+export interface SecureArray<T> extends ReadonlyArray<Secure<T>> {
+}
+export type SecureObject<T> = {
+    readonly [K in keyof T]: Secure<T[K]>;
+};
+type LooseString = (string & {});
+type LooseProperty = (PropertyKey & {});
+/** Loose union */
+export type LooseUnion<T extends string> = T | LooseString;
+/** Loose property key */
+export type LooseKey<K extends PropertyKey = string> = K | LooseProperty;
+/** Extend an object with a generic-signature */
+export type Extend<T, K extends PropertyKey = string, V = any> = T & {
+    [P in K]: V;
+};
+export {};

package/dist/type.library.js

@@ -0,0 +1,80 @@
+/** the primitive type reported by toStringTag() */
+const protoType = (obj) => Object.prototype.toString.call(obj).slice(8, -1);
+/**
+ * return an object's type as a ProperCase string.
+ * if instance, return Class name
+ */
+export const getType = (obj, ...instances) => {
+    const type = protoType(obj);
+    switch (true) {
+        case type === 'Object':
+            const name = isArrayLike(obj)
+                ? 'ArrayLike' // special case Object: ArrayLike
+                : obj.constructor?.name ?? 'Object'; // some Objects do not have a constructor method
+            return (instances
+                .find(inst => obj instanceof inst.class)?.type // allow for 'real' name of Instance, after minification
+                ?? name); // return Object name
+        case type === 'Function' && obj.valueOf().toString().startsWith('class '):
+            return 'Class';
+        default:
+            return type;
+    }
+};
+/** return TypeValue<T> object */
+export const asType = (value, ...instances) => ({ type: getType(value, ...instances), value });
+/** assert value is one of a list of Types */
+export const isType = (obj, ...types) => types.includes(getType(obj));
+/** Type-Guards: assert \<obj> is of \<type> */
+export const isPrimitive = (obj) => isType(obj, 'String', 'Number', 'BigInt', 'Boolean', 'Symbol', 'Undefined', 'Void', 'Null', 'Empty');
+export const isReference = (obj) => !isPrimitive(obj);
+export const isIterable = (obj) => Symbol.iterator in Object(obj) && !isString(obj);
+export const isString = (obj) => isType(obj, 'String');
+export const isNumber = (obj) => isType(obj, 'Number');
+export const isInteger = (obj) => isType(obj, 'BigInt');
+export const isIntegerLike = (obj) => isType(obj, 'String') && /^-?[0-9]+n$/.test(obj);
+export const isDigit = (obj) => isType(obj, 'Number', 'BigInt');
+export const isBoolean = (obj) => isType(obj, 'Boolean');
+export const isArray = (obj) => isType(obj, 'Array');
+export const isArrayLike = (obj) => protoType(obj) === 'Object' && 'length' in obj && Object.keys(obj).every(key => key === 'length' || !isNaN(Number(key)));
+export const isObject = (obj) => isType(obj, 'Object');
+export const isDate = (obj) => isType(obj, 'Date');
+export const isRegExp = (obj) => isType(obj, 'RegExp');
+export const isRegExpLike = (obj) => isType(obj, 'String') && /^\/.*\/$/.test(obj);
+export const isSymbol = (obj) => isType(obj, 'Symbol');
+export const isSymbolFor = (obj) => isType(obj, 'Symbol') && Symbol.keyFor(obj) !== void 0;
+export const isPropertyKey = (obj) => isType(obj, 'String', 'Number', 'Symbol');
+export const isNull = (obj) => isType(obj, 'Null');
+export const isNullish = (obj) => isType(obj, 'Null', 'Undefined', 'Void', 'Empty');
+export const isUndefined = (obj) => isType(obj, 'Undefined', 'Void', 'Empty');
+export const isDefined = (obj) => !isNullish(obj);
+export const isClass = (obj) => isType(obj, 'Class');
+export const isFunction = (obj) => isType(obj, 'Function', 'AsyncFunction');
+export const isPromise = (obj) => isType(obj, 'Promise');
+export const isMap = (obj) => isType(obj, 'Map');
+export const isSet = (obj) => isType(obj, 'Set');
+export const isError = (err) => isType(err, 'Error');
+export const isTemporal = (obj) => protoType(obj).startsWith('Temporal.');
+// non-standard Objects
+export const isTempo = (obj) => isType(obj, 'Tempo');
+export const isEnum = (obj) => isType(obj, 'Enumify');
+export const isPledge = (obj) => isType(obj, 'Pledge');
+export const nullToZero = (obj) => obj ?? 0;
+export const nullToEmpty = (obj) => obj ?? '';
+export const nullToValue = (obj, value) => obj ?? value;
+/** object has no values */
+export const isEmpty = (obj) => false
+    || isNullish(obj)
+    || (isObject(obj) && (Reflect.ownKeys(obj).length === 0))
+    || (isString(obj) && (obj.trim().length === 0))
+    || (isNumber(obj) && (isNaN(obj) === true))
+    || (isArray(obj) && (obj.length === 0))
+    || (isSet(obj) && (obj.size === 0))
+    || (isMap(obj) && (obj.size === 0));
+export function assertCondition(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+export function assertString(str) { assertCondition(isString(str), `Invalid string: ${str}`); }
+;
+export function assertNever(val) { throw new Error(`Unexpected object: ${val}`); }
+;

package/dist/utility.library.d.ts

@@ -0,0 +1,32 @@
+import type { Secure, ValueOf } from './type.library.js';
+/** General utility functions */
+/** analyze the Call Stack to determine calling Function's name */
+export declare const getCaller: () => string;
+/** analyze the Call Stack to determine calling Function's name */
+export declare const getScript: (nbr?: number) => string;
+/**
+ * introduce a wait-timer that will Error() on timeOut.
+ * best used with Promise.race([xxx(), sleep()]
+ * @param msg			string to display on a timeout
+ * @param timeOut	how many milliseconds to sleep (default 2-seconds)
+ * @returns				Promise\<void>
+ */
+export declare const sleep: (msg?: string, timeOut?: number) => Promise<Error>;
+/** Javascript Runtimes */
+export declare const CONTEXT: {
+    readonly Unknown: "unknown";
+    readonly Browser: "browser";
+    readonly NodeJS: "nodejs";
+    readonly Deno: "deno";
+    readonly GoogleAppsScript: "google-apps-script";
+};
+export type CONTEXT = ValueOf<typeof CONTEXT>;
+type Context = {
+    global: any;
+    type: CONTEXT;
+};
+/** determine JavaScript environment context */
+export declare const getContext: () => Context;
+/** deep-freeze an Array | Object to make it immutable */
+export declare function secure<const T>(obj: T): Secure<T>;
+export {};

package/dist/utility.library.js

@@ -0,0 +1,54 @@
+import { ownValues } from './reflection.library.js';
+import { isDefined, isReference } from './type.library.js';
+/** General utility functions */
+/** analyze the Call Stack to determine calling Function's name */
+export const getCaller = () => {
+    const stackTrace = new Error().stack // only tested in latest FF and Chrome
+        ?.split('\n')
+        ?.map(itm => itm.trim())
+        ?.filter(itm => !itm.startsWith('Error'))
+        ?? [];
+    const callerName = stackTrace[2].split(' ');
+    return (callerName[1] === 'new') ? callerName[2] : callerName[1].split('.')[0];
+};
+/** analyze the Call Stack to determine calling Function's name */
+export const getScript = (nbr = 1) => {
+    const stackTrace = new Error().stack
+        ?.match(/([^ \n\(@])*([a-z]*:\/\/\/?)*?[a-z0-9\/\\]*\.js/ig)?.[nbr];
+    return decodeURI(stackTrace ?? ''); // decodeURI is needed to handle spaces in file-names
+};
+/**
+ * introduce a wait-timer that will Error() on timeOut.
+ * best used with Promise.race([xxx(), sleep()]
+ * @param msg			string to display on a timeout
+ * @param timeOut	how many milliseconds to sleep (default 2-seconds)
+ * @returns				Promise\<void>
+ */
+export const sleep = (msg = 'sleep: timed out', timeOut = 2000) => new Promise((_, reject) => setTimeout(() => reject(new Error(msg)), timeOut));
+/** Javascript Runtimes */
+export const CONTEXT = {
+    'Unknown': 'unknown',
+    'Browser': 'browser',
+    'NodeJS': 'nodejs',
+    'Deno': 'deno',
+    'GoogleAppsScript': 'google-apps-script',
+};
+/** determine JavaScript environment context */
+export const getContext = () => {
+    const global = globalThis;
+    if (isDefined(global.SpreadsheetApp))
+        return { global, type: CONTEXT.GoogleAppsScript };
+    if (isDefined(global.window?.document))
+        return { global, type: CONTEXT.Browser };
+    if (isDefined(global.process?.versions?.node))
+        return { global, type: CONTEXT.NodeJS };
+    return { global, type: CONTEXT.Unknown };
+};
+// useful for those times when a full Enumify object is not needed, but still lock the Object from mutations
+/** deep-freeze an Array | Object to make it immutable */
+export function secure(obj) {
+    if (isReference(obj)) // skip primitive values
+        ownValues(obj) // retrieve the properties on obj
+            .forEach(val => Object.isFrozen(val) || secure(val)); // secure each value, if not already Frozen
+    return Object.freeze(obj); // freeze the object itself
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@magmacomputing/tempo",
+  "version": "1.0.0",
+  "description": "A premium, high-performance wrapper around the JavaScript Temporal API.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsc && tsc-alias",
+    "repl": "tsx -i --import ./repl.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magmacomputing/tempo.git"
+  },
+  "keywords": [
+    "Temporal",
+    "Date",
+    "Time",
+    "Parsing",
+    "Formatting",
+    "Fluent API"
+  ],
+  "author": "Michael <hello@magmacomputing.com.au>",
+  "license": "MIT",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/magmacomputing/tempo/issues"
+  },
+  "homepage": "https://github.com/magmacomputing/tempo#readme",
+  "dependencies": {
+    "@js-temporal/polyfill": "^0.5.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@vitest/ui": "^4.0.18",
+    "tsc-alias": "^1.8.16",
+    "tsx": "^4.21.0",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
+  }
+}