@synstack/resolved 1.0.0

package/README.md

@@ -0,0 +1 @@
+# @synstack/resolved

package/dist/callable/callable.index.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/callable/callable.index.ts
+var callable_index_exports = {};
+__export(callable_index_exports, {
+  callable: () => callable_bundle_exports,
+  default: () => callable_bundle_exports,
+  resolveNested: () => resolveNested
+});
+module.exports = __toCommonJS(callable_index_exports);
+
+// src/callable/callable.bundle.ts
+var callable_bundle_exports = {};
+__export(callable_bundle_exports, {
+  resolveNested: () => resolveNested
+});
+
+// src/callable/callable.lib.ts
+var resolveNested = (args) => {
+  if (args.length === 0) return [];
+  const unresolvedValues = args.map((v) => {
+    if (typeof v === "function") return v();
+    if (Array.isArray(v))
+      return v.map((sv) => typeof sv === "function" ? sv() : sv);
+    return v;
+  });
+  const isPromise = unresolvedValues.some((v) => {
+    if (v instanceof Promise) return true;
+    if (Array.isArray(v)) return v.some((v2) => v2 instanceof Promise);
+    return false;
+  });
+  if (!isPromise) return unresolvedValues;
+  return Promise.all(
+    unresolvedValues.map((v) => Array.isArray(v) ? Promise.all(v) : v)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callable,
+  resolveNested
+});
+//# sourceMappingURL=callable.index.cjs.map

package/dist/callable/callable.index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/callable/callable.index.ts","../../src/callable/callable.bundle.ts","../../src/callable/callable.lib.ts"],"sourcesContent":["export * as callable from \"./callable.bundle\";\nexport { default } from \"./callable.default\";\nexport { resolveNested } from \"./callable.lib\";\nexport type { Callable, CallableResolvable } from \"./callable.lib\";\n","export { resolveNested } from \"./callable.lib\";\n","import { Resolvable } from \"../resolvable.lib\";\n\nexport type Callable<T> = T | (() => T);\nexport declare namespace Callable {\n  export type Infer<T> = T extends () => infer U ? U : T;\n  export type IsPromise<T> = T extends () => infer U\n    ? Resolvable.IsPromise<U>\n    : Resolvable.IsPromise<T>;\n}\n\nexport type CallableResolvable<T> = Callable<Resolvable<T>>;\n\nexport declare namespace CallableResolvable {\n  export type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;\n\n  export type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;\n\n  export type Return<T> =\n    true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n\n  export type MaybeArray<T> =\n    | CallableResolvable<T>\n    | Array<CallableResolvable<T>>;\n\n  export namespace MaybeArray {\n    export type InferExact<T> = T extends readonly any[]\n      ? { [K in keyof T]: CallableResolvable.Infer<T[K]> }\n      : CallableResolvable.Infer<T>;\n    export type Infer<T> = T extends readonly any[]\n      ? Array<{ [K in keyof T]: CallableResolvable.Infer<T[K]> }[number]>\n      : CallableResolvable.Infer<T>;\n    export type IsPromise<T> = T extends readonly any[]\n      ? { [K in keyof T]: CallableResolvable.IsPromise<T[K]> }[number]\n      : CallableResolvable.IsPromise<T>;\n    export type Return<T> =\n      true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n\n    export type ArrayOf<T> = Array<MaybeArray<T>>;\n    export namespace ArrayOf {\n      export type InferExact<T extends readonly any[]> = {\n        [K in keyof T]: MaybeArray.InferExact<T[K]>;\n      };\n      export type Infer<T extends readonly any[]> = Array<\n        {\n          [K in keyof T]: MaybeArray.Infer<T[K]>;\n        }[number]\n      >;\n      export type IsPromise<T extends readonly any[]> = {\n        [K in keyof T]: MaybeArray.IsPromise<T[K]>;\n      }[number];\n      export type Return<T extends readonly any[]> =\n        true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n    }\n  }\n}\n\nexport const resolveNested = <T extends readonly any[]>(\n  args: T,\n): CallableResolvable.MaybeArray.ArrayOf.Return<T> => {\n  // @ts-expect-error - Fix later\n  if (args.length === 0) return [];\n\n  const unresolvedValues = args.map((v) => {\n    if (typeof v === \"function\") return v();\n    if (Array.isArray(v))\n      return v.map((sv) => (typeof sv === \"function\" ? sv() : sv));\n    return v;\n  });\n\n  const isPromise = unresolvedValues.some((v) => {\n    if (v instanceof Promise) return true;\n    if (Array.isArray(v)) return v.some((v) => v instanceof Promise);\n    return false;\n  });\n\n  // @ts-expect-error - We know that the values is not a promise\n  if (!isPromise) return unresolvedValues;\n\n  // @ts-expect-error - We know that the values is a promise\n  return Promise.all(\n    unresolvedValues.map((v) => (Array.isArray(v) ? Promise.all(v) : v)),\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;;;ACwDO,IAAM,gBAAgB,CAC3B,SACoD;AAEpD,MAAI,KAAK,WAAW,EAAG,QAAO,CAAC;AAE/B,QAAM,mBAAmB,KAAK,IAAI,CAAC,MAAM;AACvC,QAAI,OAAO,MAAM,WAAY,QAAO,EAAE;AACtC,QAAI,MAAM,QAAQ,CAAC;AACjB,aAAO,EAAE,IAAI,CAAC,OAAQ,OAAO,OAAO,aAAa,GAAG,IAAI,EAAG;AAC7D,WAAO;AAAA,EACT,CAAC;AAED,QAAM,YAAY,iBAAiB,KAAK,CAAC,MAAM;AAC7C,QAAI,aAAa,QAAS,QAAO;AACjC,QAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,EAAE,KAAK,CAACA,OAAMA,cAAa,OAAO;AAC/D,WAAO;AAAA,EACT,CAAC;AAGD,MAAI,CAAC,UAAW,QAAO;AAGvB,SAAO,QAAQ;AAAA,IACb,iBAAiB,IAAI,CAAC,MAAO,MAAM,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAE;AAAA,EACrE;AACF;","names":["v"]}

package/dist/callable/callable.index.d.cts

@@ -0,0 +1,47 @@
+import { R as Resolvable } from '../resolvable.lib-CU3Va7aC.cjs';
+
+type Callable<T> = T | (() => T);
+declare namespace Callable {
+    type Infer<T> = T extends () => infer U ? U : T;
+    type IsPromise<T> = T extends () => infer U ? Resolvable.IsPromise<U> : Resolvable.IsPromise<T>;
+}
+type CallableResolvable<T> = Callable<Resolvable<T>>;
+declare namespace CallableResolvable {
+    type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;
+    type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;
+    type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+    type MaybeArray<T> = CallableResolvable<T> | Array<CallableResolvable<T>>;
+    namespace MaybeArray {
+        type InferExact<T> = T extends readonly any[] ? {
+            [K in keyof T]: CallableResolvable.Infer<T[K]>;
+        } : CallableResolvable.Infer<T>;
+        type Infer<T> = T extends readonly any[] ? Array<{
+            [K in keyof T]: CallableResolvable.Infer<T[K]>;
+        }[number]> : CallableResolvable.Infer<T>;
+        type IsPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: CallableResolvable.IsPromise<T[K]>;
+        }[number] : CallableResolvable.IsPromise<T>;
+        type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+        type ArrayOf<T> = Array<MaybeArray<T>>;
+        namespace ArrayOf {
+            type InferExact<T extends readonly any[]> = {
+                [K in keyof T]: MaybeArray.InferExact<T[K]>;
+            };
+            type Infer<T extends readonly any[]> = Array<{
+                [K in keyof T]: MaybeArray.Infer<T[K]>;
+            }[number]>;
+            type IsPromise<T extends readonly any[]> = {
+                [K in keyof T]: MaybeArray.IsPromise<T[K]>;
+            }[number];
+            type Return<T extends readonly any[]> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+        }
+    }
+}
+declare const resolveNested: <T extends readonly any[]>(args: T) => CallableResolvable.MaybeArray.ArrayOf.Return<T>;
+
+declare const callable_bundle_resolveNested: typeof resolveNested;
+declare namespace callable_bundle {
+  export { callable_bundle_resolveNested as resolveNested };
+}
+
+export { Callable, CallableResolvable, callable_bundle as callable, callable_bundle as default, resolveNested };

package/dist/callable/callable.index.d.ts

@@ -0,0 +1,47 @@
+import { R as Resolvable } from '../resolvable.lib-CU3Va7aC.js';
+
+type Callable<T> = T | (() => T);
+declare namespace Callable {
+    type Infer<T> = T extends () => infer U ? U : T;
+    type IsPromise<T> = T extends () => infer U ? Resolvable.IsPromise<U> : Resolvable.IsPromise<T>;
+}
+type CallableResolvable<T> = Callable<Resolvable<T>>;
+declare namespace CallableResolvable {
+    type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;
+    type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;
+    type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+    type MaybeArray<T> = CallableResolvable<T> | Array<CallableResolvable<T>>;
+    namespace MaybeArray {
+        type InferExact<T> = T extends readonly any[] ? {
+            [K in keyof T]: CallableResolvable.Infer<T[K]>;
+        } : CallableResolvable.Infer<T>;
+        type Infer<T> = T extends readonly any[] ? Array<{
+            [K in keyof T]: CallableResolvable.Infer<T[K]>;
+        }[number]> : CallableResolvable.Infer<T>;
+        type IsPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: CallableResolvable.IsPromise<T[K]>;
+        }[number] : CallableResolvable.IsPromise<T>;
+        type Return<T> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+        type ArrayOf<T> = Array<MaybeArray<T>>;
+        namespace ArrayOf {
+            type InferExact<T extends readonly any[]> = {
+                [K in keyof T]: MaybeArray.InferExact<T[K]>;
+            };
+            type Infer<T extends readonly any[]> = Array<{
+                [K in keyof T]: MaybeArray.Infer<T[K]>;
+            }[number]>;
+            type IsPromise<T extends readonly any[]> = {
+                [K in keyof T]: MaybeArray.IsPromise<T[K]>;
+            }[number];
+            type Return<T extends readonly any[]> = true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+        }
+    }
+}
+declare const resolveNested: <T extends readonly any[]>(args: T) => CallableResolvable.MaybeArray.ArrayOf.Return<T>;
+
+declare const callable_bundle_resolveNested: typeof resolveNested;
+declare namespace callable_bundle {
+  export { callable_bundle_resolveNested as resolveNested };
+}
+
+export { Callable, CallableResolvable, callable_bundle as callable, callable_bundle as default, resolveNested };

package/dist/callable/callable.index.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/callable/callable.bundle.ts
+var callable_bundle_exports = {};
+__export(callable_bundle_exports, {
+  resolveNested: () => resolveNested
+});
+
+// src/callable/callable.lib.ts
+var resolveNested = (args) => {
+  if (args.length === 0) return [];
+  const unresolvedValues = args.map((v) => {
+    if (typeof v === "function") return v();
+    if (Array.isArray(v))
+      return v.map((sv) => typeof sv === "function" ? sv() : sv);
+    return v;
+  });
+  const isPromise = unresolvedValues.some((v) => {
+    if (v instanceof Promise) return true;
+    if (Array.isArray(v)) return v.some((v2) => v2 instanceof Promise);
+    return false;
+  });
+  if (!isPromise) return unresolvedValues;
+  return Promise.all(
+    unresolvedValues.map((v) => Array.isArray(v) ? Promise.all(v) : v)
+  );
+};
+export {
+  callable_bundle_exports as callable,
+  callable_bundle_exports as default,
+  resolveNested
+};
+//# sourceMappingURL=callable.index.js.map

package/dist/callable/callable.index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/callable/callable.bundle.ts","../../src/callable/callable.lib.ts"],"sourcesContent":["export { resolveNested } from \"./callable.lib\";\n","import { Resolvable } from \"../resolvable.lib\";\n\nexport type Callable<T> = T | (() => T);\nexport declare namespace Callable {\n  export type Infer<T> = T extends () => infer U ? U : T;\n  export type IsPromise<T> = T extends () => infer U\n    ? Resolvable.IsPromise<U>\n    : Resolvable.IsPromise<T>;\n}\n\nexport type CallableResolvable<T> = Callable<Resolvable<T>>;\n\nexport declare namespace CallableResolvable {\n  export type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;\n\n  export type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;\n\n  export type Return<T> =\n    true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n\n  export type MaybeArray<T> =\n    | CallableResolvable<T>\n    | Array<CallableResolvable<T>>;\n\n  export namespace MaybeArray {\n    export type InferExact<T> = T extends readonly any[]\n      ? { [K in keyof T]: CallableResolvable.Infer<T[K]> }\n      : CallableResolvable.Infer<T>;\n    export type Infer<T> = T extends readonly any[]\n      ? Array<{ [K in keyof T]: CallableResolvable.Infer<T[K]> }[number]>\n      : CallableResolvable.Infer<T>;\n    export type IsPromise<T> = T extends readonly any[]\n      ? { [K in keyof T]: CallableResolvable.IsPromise<T[K]> }[number]\n      : CallableResolvable.IsPromise<T>;\n    export type Return<T> =\n      true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n\n    export type ArrayOf<T> = Array<MaybeArray<T>>;\n    export namespace ArrayOf {\n      export type InferExact<T extends readonly any[]> = {\n        [K in keyof T]: MaybeArray.InferExact<T[K]>;\n      };\n      export type Infer<T extends readonly any[]> = Array<\n        {\n          [K in keyof T]: MaybeArray.Infer<T[K]>;\n        }[number]\n      >;\n      export type IsPromise<T extends readonly any[]> = {\n        [K in keyof T]: MaybeArray.IsPromise<T[K]>;\n      }[number];\n      export type Return<T extends readonly any[]> =\n        true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;\n    }\n  }\n}\n\nexport const resolveNested = <T extends readonly any[]>(\n  args: T,\n): CallableResolvable.MaybeArray.ArrayOf.Return<T> => {\n  // @ts-expect-error - Fix later\n  if (args.length === 0) return [];\n\n  const unresolvedValues = args.map((v) => {\n    if (typeof v === \"function\") return v();\n    if (Array.isArray(v))\n      return v.map((sv) => (typeof sv === \"function\" ? sv() : sv));\n    return v;\n  });\n\n  const isPromise = unresolvedValues.some((v) => {\n    if (v instanceof Promise) return true;\n    if (Array.isArray(v)) return v.some((v) => v instanceof Promise);\n    return false;\n  });\n\n  // @ts-expect-error - We know that the values is not a promise\n  if (!isPromise) return unresolvedValues;\n\n  // @ts-expect-error - We know that the values is a promise\n  return Promise.all(\n    unresolvedValues.map((v) => (Array.isArray(v) ? Promise.all(v) : v)),\n  );\n};\n"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;;;ACwDO,IAAM,gBAAgB,CAC3B,SACoD;AAEpD,MAAI,KAAK,WAAW,EAAG,QAAO,CAAC;AAE/B,QAAM,mBAAmB,KAAK,IAAI,CAAC,MAAM;AACvC,QAAI,OAAO,MAAM,WAAY,QAAO,EAAE;AACtC,QAAI,MAAM,QAAQ,CAAC;AACjB,aAAO,EAAE,IAAI,CAAC,OAAQ,OAAO,OAAO,aAAa,GAAG,IAAI,EAAG;AAC7D,WAAO;AAAA,EACT,CAAC;AAED,QAAM,YAAY,iBAAiB,KAAK,CAAC,MAAM;AAC7C,QAAI,aAAa,QAAS,QAAO;AACjC,QAAI,MAAM,QAAQ,CAAC,EAAG,QAAO,EAAE,KAAK,CAACA,OAAMA,cAAa,OAAO;AAC/D,WAAO;AAAA,EACT,CAAC;AAGD,MAAI,CAAC,UAAW,QAAO;AAGvB,SAAO,QAAQ;AAAA,IACb,iBAAiB,IAAI,CAAC,MAAO,MAAM,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAE;AAAA,EACrE;AACF;","names":["v"]}

package/dist/resolvable.lib-CU3Va7aC.d.cts

@@ -0,0 +1,63 @@
+type Resolvable<T> = Promise<T> | T;
+declare namespace Resolvable {
+    type Infer<T> = Awaited<T>;
+    type IsPromise<T> = T extends Promise<any> ? true : never;
+    namespace ArrayOf {
+        type Infer<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.Infer<T[K]>;
+        } : never;
+        type HasPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.IsPromise<T[K]>;
+        }[number] : never;
+    }
+    namespace MaybeArray {
+        type Infer<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.Infer<T[K]>;
+        } : Resolvable.Infer<T>;
+        type IsPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.IsPromise<T[K]>;
+        }[number] : Resolvable.IsPromise<T>;
+    }
+}
+/**
+ * Resolves all values in the array in parallel
+ * @param value The array to resolve
+ * @returns If the array contains promises, a promise of an array of values. Otherwise, the array.
+ */
+declare const resolveAll: <U extends readonly any[]>(value: U) => true extends Resolvable.ArrayOf.HasPromise<U> ? Promise<Resolvable.ArrayOf.Infer<U>> : U;
+declare class Resolver<T extends Resolvable<any>> {
+    private readonly _value;
+    constructor(value: T);
+    /**
+     * Get the value of the resolver
+     * @returns The value or a single promise of the value
+     *
+     * - If the value is an array containing promises, the array will be resolved with `Promise.all`
+     */
+    get $(): T extends readonly any[] ? true extends Resolvable.ArrayOf.HasPromise<T> ? Promise<Resolvable.ArrayOf.Infer<T>> : T : T;
+    valueOf(): T;
+    /**
+     * Apply a function to the value
+     * @param fn the function to apply to the value
+     * @returns a new Resolver instance with the result of the function, either a value or a promise of a value
+     */
+    _<R>(fn: (value: Resolvable.MaybeArray.Infer<T>) => R): true extends Resolvable.MaybeArray.IsPromise<T> ? true extends Resolvable.MaybeArray.IsPromise<R> ? Resolver<R> : Resolver<Promise<R>> : Resolver<R>;
+}
+/**
+ * A piping utility which preserves the sync/async state of the value
+ * @param value The value to pipe
+ * @returns A new Resolver instance
+ *
+ * ```ts
+ * import { pipe } from "@synstack/resolved";
+ *
+ * // Sync
+ * const value: string = pipe("Hello World")._((v) => v.toUpperCase()).$;
+ *
+ * // Async
+ * const promiseValue: Promise<string> = pipe("Hello World")._((v) => Promise.resolve(v.toUpperCase())).$;
+ * ```
+ */
+declare const pipe: <T>(value: T) => Resolver<T>;
+
+export { Resolvable as R, Resolver as a, pipe as p, resolveAll as r };

package/dist/resolvable.lib-CU3Va7aC.d.ts

@@ -0,0 +1,63 @@
+type Resolvable<T> = Promise<T> | T;
+declare namespace Resolvable {
+    type Infer<T> = Awaited<T>;
+    type IsPromise<T> = T extends Promise<any> ? true : never;
+    namespace ArrayOf {
+        type Infer<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.Infer<T[K]>;
+        } : never;
+        type HasPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.IsPromise<T[K]>;
+        }[number] : never;
+    }
+    namespace MaybeArray {
+        type Infer<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.Infer<T[K]>;
+        } : Resolvable.Infer<T>;
+        type IsPromise<T> = T extends readonly any[] ? {
+            [K in keyof T]: Resolvable.IsPromise<T[K]>;
+        }[number] : Resolvable.IsPromise<T>;
+    }
+}
+/**
+ * Resolves all values in the array in parallel
+ * @param value The array to resolve
+ * @returns If the array contains promises, a promise of an array of values. Otherwise, the array.
+ */
+declare const resolveAll: <U extends readonly any[]>(value: U) => true extends Resolvable.ArrayOf.HasPromise<U> ? Promise<Resolvable.ArrayOf.Infer<U>> : U;
+declare class Resolver<T extends Resolvable<any>> {
+    private readonly _value;
+    constructor(value: T);
+    /**
+     * Get the value of the resolver
+     * @returns The value or a single promise of the value
+     *
+     * - If the value is an array containing promises, the array will be resolved with `Promise.all`
+     */
+    get $(): T extends readonly any[] ? true extends Resolvable.ArrayOf.HasPromise<T> ? Promise<Resolvable.ArrayOf.Infer<T>> : T : T;
+    valueOf(): T;
+    /**
+     * Apply a function to the value
+     * @param fn the function to apply to the value
+     * @returns a new Resolver instance with the result of the function, either a value or a promise of a value
+     */
+    _<R>(fn: (value: Resolvable.MaybeArray.Infer<T>) => R): true extends Resolvable.MaybeArray.IsPromise<T> ? true extends Resolvable.MaybeArray.IsPromise<R> ? Resolver<R> : Resolver<Promise<R>> : Resolver<R>;
+}
+/**
+ * A piping utility which preserves the sync/async state of the value
+ * @param value The value to pipe
+ * @returns A new Resolver instance
+ *
+ * ```ts
+ * import { pipe } from "@synstack/resolved";
+ *
+ * // Sync
+ * const value: string = pipe("Hello World")._((v) => v.toUpperCase()).$;
+ *
+ * // Async
+ * const promiseValue: Promise<string> = pipe("Hello World")._((v) => Promise.resolve(v.toUpperCase())).$;
+ * ```
+ */
+declare const pipe: <T>(value: T) => Resolver<T>;
+
+export { Resolvable as R, Resolver as a, pipe as p, resolveAll as r };

package/dist/resolved.index.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resolved.index.ts
+var resolved_index_exports = {};
+__export(resolved_index_exports, {
+  pipe: () => pipe,
+  resolvable: () => resolved_bundle_exports,
+  resolveAll: () => resolveAll
+});
+module.exports = __toCommonJS(resolved_index_exports);
+
+// src/resolved.bundle.ts
+var resolved_bundle_exports = {};
+__export(resolved_bundle_exports, {
+  pipe: () => pipe,
+  resolveAll: () => resolveAll
+});
+
+// src/resolvable.lib.ts
+var resolveAll = (value) => {
+  if (!Array.isArray(value)) throw new Error("Expected an array");
+  if (value.some((v) => v instanceof Promise)) return Promise.all(value);
+  return value;
+};
+var Resolver = class _Resolver {
+  _value;
+  constructor(value) {
+    this._value = value;
+  }
+  /**
+   * Get the value of the resolver
+   * @returns The value or a single promise of the value
+   *
+   * - If the value is an array containing promises, the array will be resolved with `Promise.all`
+   */
+  get $() {
+    if (Array.isArray(this._value)) {
+      return resolveAll(this._value);
+    }
+    return this._value;
+  }
+  valueOf() {
+    return this._value;
+  }
+  /**
+   * Apply a function to the value
+   * @param fn the function to apply to the value
+   * @returns a new Resolver instance with the result of the function, either a value or a promise of a value
+   */
+  _(fn) {
+    if (Array.isArray(this._value)) {
+      const hasPromise = this._value.some((v) => v instanceof Promise);
+      if (hasPromise)
+        return new _Resolver(Promise.all(this._value).then(fn));
+      return new _Resolver(fn(this._value));
+    }
+    if (this._value instanceof Promise)
+      return new _Resolver(this._value.then(fn));
+    return new _Resolver(fn(this._value));
+  }
+};
+var pipe = (value) => {
+  return new Resolver(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipe,
+  resolvable,
+  resolveAll
+});
+//# sourceMappingURL=resolved.index.cjs.map

package/dist/resolved.index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resolved.index.ts","../src/resolved.bundle.ts","../src/resolvable.lib.ts"],"sourcesContent":["export type { Resolvable, Resolver } from \"./resolvable.lib\";\nexport * from \"./resolved.bundle\";\nexport * as resolvable from \"./resolved.bundle\";\n","export { pipe, resolveAll } from \"./resolvable.lib\";\n","export type Resolvable<T> = Promise<T> | T;\n\nexport declare namespace Resolvable {\n  export type Infer<T> = Awaited<T>;\n  export type IsPromise<T> = T extends Promise<any> ? true : never;\n\n  namespace ArrayOf {\n    export type Infer<T> = T extends readonly any[]\n      ? {\n          [K in keyof T]: Resolvable.Infer<T[K]>;\n        }\n      : never;\n\n    export type HasPromise<T> = T extends readonly any[]\n      ? {\n          [K in keyof T]: Resolvable.IsPromise<T[K]>;\n        }[number]\n      : never;\n  }\n\n  namespace MaybeArray {\n    export type Infer<T> = T extends readonly any[]\n      ? { [K in keyof T]: Resolvable.Infer<T[K]> }\n      : Resolvable.Infer<T>;\n\n    export type IsPromise<T> = T extends readonly any[]\n      ? { [K in keyof T]: Resolvable.IsPromise<T[K]> }[number]\n      : Resolvable.IsPromise<T>;\n  }\n}\n\n/**\n * Resolves all values in the array in parallel\n * @param value The array to resolve\n * @returns If the array contains promises, a promise of an array of values. Otherwise, the array.\n */\nexport const resolveAll = <U extends readonly any[]>(\n  value: U,\n): true extends Resolvable.ArrayOf.HasPromise<U>\n  ? Promise<Resolvable.ArrayOf.Infer<U>>\n  : U => {\n  if (!Array.isArray(value)) throw new Error(\"Expected an array\");\n  // @ts-expect-error - We know that the value is not a promise\n  if (value.some((v) => v instanceof Promise)) return Promise.all(value);\n  // @ts-expect-error - We know that the value is not a promise\n  return value;\n};\n\nexport class Resolver<T extends Resolvable<any>> {\n  private readonly _value: T;\n\n  public constructor(value: T) {\n    this._value = value;\n  }\n\n  /**\n   * Get the value of the resolver\n   * @returns The value or a single promise of the value\n   *\n   * - If the value is an array containing promises, the array will be resolved with `Promise.all`\n   */\n  public get $(): T extends readonly any[]\n    ? true extends Resolvable.ArrayOf.HasPromise<T>\n      ? Promise<Resolvable.ArrayOf.Infer<T>>\n      : T\n    : T {\n    if (Array.isArray(this._value)) {\n      // @ts-expect-error - We know that the value is an array\n      return resolveAll(this._value);\n    }\n    // @ts-expect-error - We know that the value is not an array\n    return this._value;\n  }\n\n  public valueOf(): T {\n    return this._value;\n  }\n\n  /**\n   * Apply a function to the value\n   * @param fn the function to apply to the value\n   * @returns a new Resolver instance with the result of the function, either a value or a promise of a value\n   */\n  public _<R>(\n    fn: (value: Resolvable.MaybeArray.Infer<T>) => R,\n  ): true extends Resolvable.MaybeArray.IsPromise<T>\n    ? true extends Resolvable.MaybeArray.IsPromise<R>\n      ? Resolver<R>\n      : Resolver<Promise<R>>\n    : Resolver<R> {\n    if (Array.isArray(this._value)) {\n      const hasPromise = this._value.some((v) => v instanceof Promise);\n      if (hasPromise)\n        // @ts-expect-error - We know that the value is a promise\n        return new Resolver(Promise.all(this._value).then(fn));\n      // @ts-expect-error - We know that the value is not a promise\n      return new Resolver(fn(this._value));\n    }\n    if (this._value instanceof Promise)\n      // @ts-expect-error - We know that the value is a promise\n      return new Resolver(this._value.then(fn));\n    // @ts-expect-error - We know that the value is not a promise\n    return new Resolver(fn(this._value as Resolvable.Infer<T>));\n  }\n}\n\n/**\n * A piping utility which preserves the sync/async state of the value\n * @param value The value to pipe\n * @returns A new Resolver instance\n *\n * ```ts\n * import { pipe } from \"@synstack/resolved\";\n *\n * // Sync\n * const value: string = pipe(\"Hello World\")._((v) => v.toUpperCase()).$;\n *\n * // Async\n * const promiseValue: Promise<string> = pipe(\"Hello World\")._((v) => Promise.resolve(v.toUpperCase())).$;\n * ```\n */\nexport const pipe = <T>(value: T) => {\n  return new Resolver<T>(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAAA;;;ACoCO,IAAM,aAAa,CACxB,UAGO;AACP,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,OAAM,IAAI,MAAM,mBAAmB;AAE9D,MAAI,MAAM,KAAK,CAAC,MAAM,aAAa,OAAO,EAAG,QAAO,QAAQ,IAAI,KAAK;AAErE,SAAO;AACT;AAEO,IAAM,WAAN,MAAM,UAAoC;AAAA,EAC9B;AAAA,EAEV,YAAY,OAAU;AAC3B,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAW,IAIL;AACJ,QAAI,MAAM,QAAQ,KAAK,MAAM,GAAG;AAE9B,aAAO,WAAW,KAAK,MAAM;AAAA,IAC/B;AAEA,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,UAAa;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,EACL,IAKc;AACd,QAAI,MAAM,QAAQ,KAAK,MAAM,GAAG;AAC9B,YAAM,aAAa,KAAK,OAAO,KAAK,CAAC,MAAM,aAAa,OAAO;AAC/D,UAAI;AAEF,eAAO,IAAI,UAAS,QAAQ,IAAI,KAAK,MAAM,EAAE,KAAK,EAAE,CAAC;AAEvD,aAAO,IAAI,UAAS,GAAG,KAAK,MAAM,CAAC;AAAA,IACrC;AACA,QAAI,KAAK,kBAAkB;AAEzB,aAAO,IAAI,UAAS,KAAK,OAAO,KAAK,EAAE,CAAC;AAE1C,WAAO,IAAI,UAAS,GAAG,KAAK,MAA6B,CAAC;AAAA,EAC5D;AACF;AAiBO,IAAM,OAAO,CAAI,UAAa;AACnC,SAAO,IAAI,SAAY,KAAK;AAC9B;","names":[]}

package/dist/resolved.index.d.cts

@@ -0,0 +1,10 @@
+import { p as pipe, r as resolveAll } from './resolvable.lib-CU3Va7aC.cjs';
+export { R as Resolvable, a as Resolver } from './resolvable.lib-CU3Va7aC.cjs';
+
+declare const resolved_bundle_pipe: typeof pipe;
+declare const resolved_bundle_resolveAll: typeof resolveAll;
+declare namespace resolved_bundle {
+  export { resolved_bundle_pipe as pipe, resolved_bundle_resolveAll as resolveAll };
+}
+
+export { pipe, resolved_bundle as resolvable, resolveAll };

package/dist/resolved.index.d.ts

@@ -0,0 +1,10 @@
+import { p as pipe, r as resolveAll } from './resolvable.lib-CU3Va7aC.js';
+export { R as Resolvable, a as Resolver } from './resolvable.lib-CU3Va7aC.js';
+
+declare const resolved_bundle_pipe: typeof pipe;
+declare const resolved_bundle_resolveAll: typeof resolveAll;
+declare namespace resolved_bundle {
+  export { resolved_bundle_pipe as pipe, resolved_bundle_resolveAll as resolveAll };
+}
+
+export { pipe, resolved_bundle as resolvable, resolveAll };

package/dist/resolved.index.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/resolved.bundle.ts
+var resolved_bundle_exports = {};
+__export(resolved_bundle_exports, {
+  pipe: () => pipe,
+  resolveAll: () => resolveAll
+});
+
+// src/resolvable.lib.ts
+var resolveAll = (value) => {
+  if (!Array.isArray(value)) throw new Error("Expected an array");
+  if (value.some((v) => v instanceof Promise)) return Promise.all(value);
+  return value;
+};
+var Resolver = class _Resolver {
+  _value;
+  constructor(value) {
+    this._value = value;
+  }
+  /**
+   * Get the value of the resolver
+   * @returns The value or a single promise of the value
+   *
+   * - If the value is an array containing promises, the array will be resolved with `Promise.all`
+   */
+  get $() {
+    if (Array.isArray(this._value)) {
+      return resolveAll(this._value);
+    }
+    return this._value;
+  }
+  valueOf() {
+    return this._value;
+  }
+  /**
+   * Apply a function to the value
+   * @param fn the function to apply to the value
+   * @returns a new Resolver instance with the result of the function, either a value or a promise of a value
+   */
+  _(fn) {
+    if (Array.isArray(this._value)) {
+      const hasPromise = this._value.some((v) => v instanceof Promise);
+      if (hasPromise)
+        return new _Resolver(Promise.all(this._value).then(fn));
+      return new _Resolver(fn(this._value));
+    }
+    if (this._value instanceof Promise)
+      return new _Resolver(this._value.then(fn));
+    return new _Resolver(fn(this._value));
+  }
+};
+var pipe = (value) => {
+  return new Resolver(value);
+};
+export {
+  pipe,
+  resolved_bundle_exports as resolvable,
+  resolveAll
+};
+//# sourceMappingURL=resolved.index.js.map

package/dist/resolved.index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resolved.bundle.ts","../src/resolvable.lib.ts"],"sourcesContent":["export { pipe, resolveAll } from \"./resolvable.lib\";\n","export type Resolvable<T> = Promise<T> | T;\n\nexport declare namespace Resolvable {\n  export type Infer<T> = Awaited<T>;\n  export type IsPromise<T> = T extends Promise<any> ? true : never;\n\n  namespace ArrayOf {\n    export type Infer<T> = T extends readonly any[]\n      ? {\n          [K in keyof T]: Resolvable.Infer<T[K]>;\n        }\n      : never;\n\n    export type HasPromise<T> = T extends readonly any[]\n      ? {\n          [K in keyof T]: Resolvable.IsPromise<T[K]>;\n        }[number]\n      : never;\n  }\n\n  namespace MaybeArray {\n    export type Infer<T> = T extends readonly any[]\n      ? { [K in keyof T]: Resolvable.Infer<T[K]> }\n      : Resolvable.Infer<T>;\n\n    export type IsPromise<T> = T extends readonly any[]\n      ? { [K in keyof T]: Resolvable.IsPromise<T[K]> }[number]\n      : Resolvable.IsPromise<T>;\n  }\n}\n\n/**\n * Resolves all values in the array in parallel\n * @param value The array to resolve\n * @returns If the array contains promises, a promise of an array of values. Otherwise, the array.\n */\nexport const resolveAll = <U extends readonly any[]>(\n  value: U,\n): true extends Resolvable.ArrayOf.HasPromise<U>\n  ? Promise<Resolvable.ArrayOf.Infer<U>>\n  : U => {\n  if (!Array.isArray(value)) throw new Error(\"Expected an array\");\n  // @ts-expect-error - We know that the value is not a promise\n  if (value.some((v) => v instanceof Promise)) return Promise.all(value);\n  // @ts-expect-error - We know that the value is not a promise\n  return value;\n};\n\nexport class Resolver<T extends Resolvable<any>> {\n  private readonly _value: T;\n\n  public constructor(value: T) {\n    this._value = value;\n  }\n\n  /**\n   * Get the value of the resolver\n   * @returns The value or a single promise of the value\n   *\n   * - If the value is an array containing promises, the array will be resolved with `Promise.all`\n   */\n  public get $(): T extends readonly any[]\n    ? true extends Resolvable.ArrayOf.HasPromise<T>\n      ? Promise<Resolvable.ArrayOf.Infer<T>>\n      : T\n    : T {\n    if (Array.isArray(this._value)) {\n      // @ts-expect-error - We know that the value is an array\n      return resolveAll(this._value);\n    }\n    // @ts-expect-error - We know that the value is not an array\n    return this._value;\n  }\n\n  public valueOf(): T {\n    return this._value;\n  }\n\n  /**\n   * Apply a function to the value\n   * @param fn the function to apply to the value\n   * @returns a new Resolver instance with the result of the function, either a value or a promise of a value\n   */\n  public _<R>(\n    fn: (value: Resolvable.MaybeArray.Infer<T>) => R,\n  ): true extends Resolvable.MaybeArray.IsPromise<T>\n    ? true extends Resolvable.MaybeArray.IsPromise<R>\n      ? Resolver<R>\n      : Resolver<Promise<R>>\n    : Resolver<R> {\n    if (Array.isArray(this._value)) {\n      const hasPromise = this._value.some((v) => v instanceof Promise);\n      if (hasPromise)\n        // @ts-expect-error - We know that the value is a promise\n        return new Resolver(Promise.all(this._value).then(fn));\n      // @ts-expect-error - We know that the value is not a promise\n      return new Resolver(fn(this._value));\n    }\n    if (this._value instanceof Promise)\n      // @ts-expect-error - We know that the value is a promise\n      return new Resolver(this._value.then(fn));\n    // @ts-expect-error - We know that the value is not a promise\n    return new Resolver(fn(this._value as Resolvable.Infer<T>));\n  }\n}\n\n/**\n * A piping utility which preserves the sync/async state of the value\n * @param value The value to pipe\n * @returns A new Resolver instance\n *\n * ```ts\n * import { pipe } from \"@synstack/resolved\";\n *\n * // Sync\n * const value: string = pipe(\"Hello World\")._((v) => v.toUpperCase()).$;\n *\n * // Async\n * const promiseValue: Promise<string> = pipe(\"Hello World\")._((v) => Promise.resolve(v.toUpperCase())).$;\n * ```\n */\nexport const pipe = <T>(value: T) => {\n  return new Resolver<T>(value);\n};\n"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACoCO,IAAM,aAAa,CACxB,UAGO;AACP,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,OAAM,IAAI,MAAM,mBAAmB;AAE9D,MAAI,MAAM,KAAK,CAAC,MAAM,aAAa,OAAO,EAAG,QAAO,QAAQ,IAAI,KAAK;AAErE,SAAO;AACT;AAEO,IAAM,WAAN,MAAM,UAAoC;AAAA,EAC9B;AAAA,EAEV,YAAY,OAAU;AAC3B,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAW,IAIL;AACJ,QAAI,MAAM,QAAQ,KAAK,MAAM,GAAG;AAE9B,aAAO,WAAW,KAAK,MAAM;AAAA,IAC/B;AAEA,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,UAAa;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,EACL,IAKc;AACd,QAAI,MAAM,QAAQ,KAAK,MAAM,GAAG;AAC9B,YAAM,aAAa,KAAK,OAAO,KAAK,CAAC,MAAM,aAAa,OAAO;AAC/D,UAAI;AAEF,eAAO,IAAI,UAAS,QAAQ,IAAI,KAAK,MAAM,EAAE,KAAK,EAAE,CAAC;AAEvD,aAAO,IAAI,UAAS,GAAG,KAAK,MAAM,CAAC;AAAA,IACrC;AACA,QAAI,KAAK,kBAAkB;AAEzB,aAAO,IAAI,UAAS,KAAK,OAAO,KAAK,EAAE,CAAC;AAE1C,WAAO,IAAI,UAAS,GAAG,KAAK,MAA6B,CAAC;AAAA,EAC5D;AACF;AAiBO,IAAM,OAAO,CAAI,UAAa;AACnC,SAAO,IAAI,SAAY,KAAK;AAC9B;","names":[]}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@synstack/resolved",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "yarn@4.4.0",
+  "version": "1.0.0",
+  "author": {
+    "name": "pAIrprog",
+    "url": "https://pairprog.io"
+  },
+  "homepage": "https://github.com/pAIrprogio/synscript/tree/main/packages/resolved",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pAIrprogio/syn-stack.git",
+    "directory": "packages/resolved"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "publish": "yarn npm publish --access public",
+    "prepublish": "yarn test && yarn build",
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "test:types": "tsc --noEmit",
+    "test:unit": "node --import tsx --test src/**/*.test.ts",
+    "test:unit:watch": "node --import tsx --watch --test src/**/*.test.ts",
+    "test": "yarn test:types && yarn test:unit"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/resolved.index.d.ts",
+        "default": "./dist/resolved.index.js"
+      },
+      "require": {
+        "types": "./dist/resolved.index.d.cts",
+        "default": "./dist/resolved.index.cjs"
+      }
+    },
+    "./callable": {
+      "import": {
+        "types": "./src/callable/callable.index.ts",
+        "default": "./dist/callable/callable.index.js"
+      },
+      "require": {
+        "types": "./dist/callable/callable.index.d.cts",
+        "default": "./dist/callable/callable.index.cjs"
+      }
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2"
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "dist/**/*"
+  ],
+  "gitHead": "c668ecfd7fe387e978a68324e760d1ed13182d11"
+}

package/src/callable/callable.bundle.ts

@@ -0,0 +1 @@
+export { resolveNested } from "./callable.lib";

package/src/callable/callable.default.ts

@@ -0,0 +1 @@
+export * as default from "./callable.bundle";

package/src/callable/callable.index.ts

@@ -0,0 +1,4 @@
+export * as callable from "./callable.bundle";
+export { default } from "./callable.default";
+export { resolveNested } from "./callable.lib";
+export type { Callable, CallableResolvable } from "./callable.lib";

package/src/callable/callable.lib.ts

@@ -0,0 +1,83 @@
+import { Resolvable } from "../resolvable.lib";
+
+export type Callable<T> = T | (() => T);
+export declare namespace Callable {
+  export type Infer<T> = T extends () => infer U ? U : T;
+  export type IsPromise<T> = T extends () => infer U
+    ? Resolvable.IsPromise<U>
+    : Resolvable.IsPromise<T>;
+}
+
+export type CallableResolvable<T> = Callable<Resolvable<T>>;
+
+export declare namespace CallableResolvable {
+  export type Infer<T> = Resolvable.Infer<Callable.Infer<T>>;
+
+  export type IsPromise<T> = Resolvable.IsPromise<Callable.Infer<T>>;
+
+  export type Return<T> =
+    true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+
+  export type MaybeArray<T> =
+    | CallableResolvable<T>
+    | Array<CallableResolvable<T>>;
+
+  export namespace MaybeArray {
+    export type InferExact<T> = T extends readonly any[]
+      ? { [K in keyof T]: CallableResolvable.Infer<T[K]> }
+      : CallableResolvable.Infer<T>;
+    export type Infer<T> = T extends readonly any[]
+      ? Array<{ [K in keyof T]: CallableResolvable.Infer<T[K]> }[number]>
+      : CallableResolvable.Infer<T>;
+    export type IsPromise<T> = T extends readonly any[]
+      ? { [K in keyof T]: CallableResolvable.IsPromise<T[K]> }[number]
+      : CallableResolvable.IsPromise<T>;
+    export type Return<T> =
+      true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+
+    export type ArrayOf<T> = Array<MaybeArray<T>>;
+    export namespace ArrayOf {
+      export type InferExact<T extends readonly any[]> = {
+        [K in keyof T]: MaybeArray.InferExact<T[K]>;
+      };
+      export type Infer<T extends readonly any[]> = Array<
+        {
+          [K in keyof T]: MaybeArray.Infer<T[K]>;
+        }[number]
+      >;
+      export type IsPromise<T extends readonly any[]> = {
+        [K in keyof T]: MaybeArray.IsPromise<T[K]>;
+      }[number];
+      export type Return<T extends readonly any[]> =
+        true extends IsPromise<T> ? Promise<Infer<T>> : Infer<T>;
+    }
+  }
+}
+
+export const resolveNested = <T extends readonly any[]>(
+  args: T,
+): CallableResolvable.MaybeArray.ArrayOf.Return<T> => {
+  // @ts-expect-error - Fix later
+  if (args.length === 0) return [];
+
+  const unresolvedValues = args.map((v) => {
+    if (typeof v === "function") return v();
+    if (Array.isArray(v))
+      return v.map((sv) => (typeof sv === "function" ? sv() : sv));
+    return v;
+  });
+
+  const isPromise = unresolvedValues.some((v) => {
+    if (v instanceof Promise) return true;
+    if (Array.isArray(v)) return v.some((v) => v instanceof Promise);
+    return false;
+  });
+
+  // @ts-expect-error - We know that the values is not a promise
+  if (!isPromise) return unresolvedValues;
+
+  // @ts-expect-error - We know that the values is a promise
+  return Promise.all(
+    unresolvedValues.map((v) => (Array.isArray(v) ? Promise.all(v) : v)),
+  );
+};

package/src/resolvable.lib.ts

@@ -0,0 +1,124 @@
+export type Resolvable<T> = Promise<T> | T;
+
+export declare namespace Resolvable {
+  export type Infer<T> = Awaited<T>;
+  export type IsPromise<T> = T extends Promise<any> ? true : never;
+
+  namespace ArrayOf {
+    export type Infer<T> = T extends readonly any[]
+      ? {
+          [K in keyof T]: Resolvable.Infer<T[K]>;
+        }
+      : never;
+
+    export type HasPromise<T> = T extends readonly any[]
+      ? {
+          [K in keyof T]: Resolvable.IsPromise<T[K]>;
+        }[number]
+      : never;
+  }
+
+  namespace MaybeArray {
+    export type Infer<T> = T extends readonly any[]
+      ? { [K in keyof T]: Resolvable.Infer<T[K]> }
+      : Resolvable.Infer<T>;
+
+    export type IsPromise<T> = T extends readonly any[]
+      ? { [K in keyof T]: Resolvable.IsPromise<T[K]> }[number]
+      : Resolvable.IsPromise<T>;
+  }
+}
+
+/**
+ * Resolves all values in the array in parallel
+ * @param value The array to resolve
+ * @returns If the array contains promises, a promise of an array of values. Otherwise, the array.
+ */
+export const resolveAll = <U extends readonly any[]>(
+  value: U,
+): true extends Resolvable.ArrayOf.HasPromise<U>
+  ? Promise<Resolvable.ArrayOf.Infer<U>>
+  : U => {
+  if (!Array.isArray(value)) throw new Error("Expected an array");
+  // @ts-expect-error - We know that the value is not a promise
+  if (value.some((v) => v instanceof Promise)) return Promise.all(value);
+  // @ts-expect-error - We know that the value is not a promise
+  return value;
+};
+
+export class Resolver<T extends Resolvable<any>> {
+  private readonly _value: T;
+
+  public constructor(value: T) {
+    this._value = value;
+  }
+
+  /**
+   * Get the value of the resolver
+   * @returns The value or a single promise of the value
+   *
+   * - If the value is an array containing promises, the array will be resolved with `Promise.all`
+   */
+  public get $(): T extends readonly any[]
+    ? true extends Resolvable.ArrayOf.HasPromise<T>
+      ? Promise<Resolvable.ArrayOf.Infer<T>>
+      : T
+    : T {
+    if (Array.isArray(this._value)) {
+      // @ts-expect-error - We know that the value is an array
+      return resolveAll(this._value);
+    }
+    // @ts-expect-error - We know that the value is not an array
+    return this._value;
+  }
+
+  public valueOf(): T {
+    return this._value;
+  }
+
+  /**
+   * Apply a function to the value
+   * @param fn the function to apply to the value
+   * @returns a new Resolver instance with the result of the function, either a value or a promise of a value
+   */
+  public _<R>(
+    fn: (value: Resolvable.MaybeArray.Infer<T>) => R,
+  ): true extends Resolvable.MaybeArray.IsPromise<T>
+    ? true extends Resolvable.MaybeArray.IsPromise<R>
+      ? Resolver<R>
+      : Resolver<Promise<R>>
+    : Resolver<R> {
+    if (Array.isArray(this._value)) {
+      const hasPromise = this._value.some((v) => v instanceof Promise);
+      if (hasPromise)
+        // @ts-expect-error - We know that the value is a promise
+        return new Resolver(Promise.all(this._value).then(fn));
+      // @ts-expect-error - We know that the value is not a promise
+      return new Resolver(fn(this._value));
+    }
+    if (this._value instanceof Promise)
+      // @ts-expect-error - We know that the value is a promise
+      return new Resolver(this._value.then(fn));
+    // @ts-expect-error - We know that the value is not a promise
+    return new Resolver(fn(this._value as Resolvable.Infer<T>));
+  }
+}
+
+/**
+ * A piping utility which preserves the sync/async state of the value
+ * @param value The value to pipe
+ * @returns A new Resolver instance
+ *
+ * ```ts
+ * import { pipe } from "@synstack/resolved";
+ *
+ * // Sync
+ * const value: string = pipe("Hello World")._((v) => v.toUpperCase()).$;
+ *
+ * // Async
+ * const promiseValue: Promise<string> = pipe("Hello World")._((v) => Promise.resolve(v.toUpperCase())).$;
+ * ```
+ */
+export const pipe = <T>(value: T) => {
+  return new Resolver<T>(value);
+};

package/src/resolved.bundle.ts

@@ -0,0 +1 @@
+export { pipe, resolveAll } from "./resolvable.lib";

package/src/resolved.index.ts

@@ -0,0 +1,3 @@
+export type { Resolvable, Resolver } from "./resolvable.lib";
+export * from "./resolved.bundle";
+export * as resolvable from "./resolved.bundle";