quansync - npm Package Compare versions

Comparing version 0.3.0 to 1.0.0

dist/index.d.ts

+import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-CSnozp72.js";
+
+//#region src/index.d.ts
+declare const GET_IS_ASYNC: unique symbol;
+declare class QuansyncError extends Error {
+  constructor(message?: string);
+}
+/**
+ * Creates a new Quansync function, a "superposition" between async and sync.
+ */
+declare function quansync<Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
+declare function quansync<Return, Args extends any[] = []>(input: QuansyncGeneratorFn<Return, Args> | Promise<Return>, options?: QuansyncOptions): QuansyncFn<Return, Args>;
+/**
+ * Converts a promise to a Quansync generator.
+ */
+declare function toGenerator<T>(promise: Promise<T> | QuansyncGenerator<T> | T): QuansyncGenerator<T>;
+/**
+ * @returns `true` if the current context is async, `false` otherwise.
+ */
+declare const getIsAsync: QuansyncFn<boolean, []>;
+//#endregion
+export { GET_IS_ASYNC, QuansyncAwaitableGenerator, QuansyncError, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, getIsAsync, quansync, toGenerator };

dist/index.js

+import { a as toGenerator, i as quansync, n as QuansyncError, r as getIsAsync, t as GET_IS_ASYNC } from "./src-C2Pm6gXo.js";
+
+export { GET_IS_ASYNC, QuansyncError, getIsAsync, quansync, toGenerator };

dist/macro.d.ts

+import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-CSnozp72.js";
+
+//#region src/macro.d.ts
+
+/**
+ * This function is equivalent to `quansync` from main entry
+ * but accepts a fake argument type of async functions.
+ *
+ * This requires to be used with the macro transformer `unplugin-quansync`.
+ * Do NOT use it directly.
+ *
+ * @internal
+ */
+declare const quansync: {
+  <Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
+  <Return, Args extends any[] = []>(input: Promise<Return> | QuansyncGeneratorFn<Return, Args> | ((...args: Args) => Return | Promise<Return>), options?: QuansyncOptions | undefined): QuansyncFn<Return, Args>;
+};
+//#endregion
+export { QuansyncAwaitableGenerator, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, quansync };

dist/macro.js

+import { i as quansync$1 } from "./src-C2Pm6gXo.js";
+
+//#region src/macro.ts
+/**
+* This function is equivalent to `quansync` from main entry
+* but accepts a fake argument type of async functions.
+*
+* This requires to be used with the macro transformer `unplugin-quansync`.
+* Do NOT use it directly.
+*
+* @internal
+*/
+const quansync = quansync$1;
+
+//#endregion
+export { quansync };

dist/src-C2Pm6gXo.js

+//#region src/index.ts
+const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+var QuansyncError = class extends Error {
+	constructor(message = "Unexpected promise in sync context") {
+		super(message);
+		this.name = "QuansyncError";
+	}
+};
+function isThenable(value) {
+	return value && typeof value === "object" && typeof value.then === "function";
+}
+function isQuansyncGenerator(value) {
+	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
+}
+function fromObject(options) {
+	const generator = function* (...args) {
+		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
+		return options.sync.apply(this, args);
+	};
+	function fn(...args) {
+		const iter = generator.apply(this, args);
+		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
+		iter.__quansync = true;
+		return iter;
+	}
+	fn.sync = options.sync;
+	fn.async = options.async;
+	return fn;
+}
+function fromPromise(promise) {
+	return fromObject({
+		async: () => Promise.resolve(promise),
+		sync: () => {
+			if (isThenable(promise)) throw new QuansyncError();
+			return promise;
+		}
+	});
+}
+function unwrapYield(value, isAsync) {
+	if (value === GET_IS_ASYNC) return isAsync;
+	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
+	if (!isAsync && isThenable(value)) throw new QuansyncError();
+	return value;
+}
+const DEFAULT_ON_YIELD = (value) => value;
+function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(unwrapYield(onYield(current.value, false)));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return unwrapYield(current.value);
+}
+async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(await unwrapYield(onYield(current.value, true), true));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return current.value;
+}
+function fromGeneratorFn(generatorFn, options) {
+	return fromObject({
+		name: generatorFn.name,
+		async(...args) {
+			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
+		},
+		sync(...args) {
+			return iterateSync(generatorFn.apply(this, args), options?.onYield);
+		}
+	});
+}
+function quansync(input, options) {
+	if (isThenable(input)) return fromPromise(input);
+	if (typeof input === "function") return fromGeneratorFn(input, options);
+	else return fromObject(input);
+}
+/**
+* Converts a promise to a Quansync generator.
+*/
+function toGenerator(promise) {
+	if (isQuansyncGenerator(promise)) return promise;
+	return fromPromise(promise)();
+}
+/**
+* @returns `true` if the current context is async, `false` otherwise.
+*/
+const getIsAsync = quansync({
+	async: () => Promise.resolve(true),
+	sync: () => false
+});
+
+//#endregion
+export { toGenerator as a, quansync as i, QuansyncError as n, getIsAsync as r, GET_IS_ASYNC as t };

dist/types-CSnozp72.d.ts

+//#region src/types.d.ts
+interface QuansyncOptions {
+  onYield?: (value: any, isAsync: boolean) => any;
+}
+interface QuansyncInputObject<Return, Args extends any[]> extends QuansyncOptions {
+  name?: string;
+  sync: (...args: Args) => Return;
+  async: (...args: Args) => Promise<Return>;
+}
+type QuansyncGeneratorFn<Return, Args extends any[]> = ((...args: Args) => QuansyncGenerator<Return>);
+type QuansyncInput<Return, Args extends any[]> = QuansyncInputObject<Return, Args> | QuansyncGeneratorFn<Return, Args>;
+type QuansyncGenerator<Return = any, Yield = unknown> = Generator<Yield, Return, Awaited<Yield>> & {
+  __quansync?: true;
+};
+type QuansyncAwaitableGenerator<Return = any, Yield = unknown> = QuansyncGenerator<Return, Yield> & PromiseLike<Return>;
+/**
+ * "Superposition" function that can be consumed in both sync and async contexts.
+ */
+type QuansyncFn<Return = any, Args extends any[] = []> = ((...args: Args) => QuansyncAwaitableGenerator<Return>) & {
+  /**
+   * **Warning**: The `async` and `sync` methods will be lost after invoked.
+   */
+  bind: <T, A extends any[], B extends any[]>(this: (this: T, ...args: [...A, ...B]) => QuansyncAwaitableGenerator<Return>, thisArg: T, ...args: A) => ((...args: B) => QuansyncAwaitableGenerator<Return>);
+  sync: (...args: Args) => Return;
+  async: (...args: Args) => Promise<Return>;
+};
+//#endregion
+export { QuansyncInput as a, QuansyncGeneratorFn as i, QuansyncFn as n, QuansyncInputObject as o, QuansyncGenerator as r, QuansyncOptions as s, QuansyncAwaitableGenerator as t };

package.json

 {
   "name": "quansync",
   "type": "module",
-  "version": "0.3.0",
+  "version": "1.0.0",
   "description": "Create sync/async APIs with usable logic",
@@ -37,15 +37,9 @@ "author": "Anthony Fu <[e-mail]>",
   "exports": {
-    ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs"
-    },
-    "./macro": {
-      "require": "./dist/macro.cjs",
-      "import": "./dist/macro.mjs"
-    },
+    ".": "./dist/index.js",
+    "./macro": "./dist/macro.js",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.cts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -52,0 +46,0 @@ "*": {

dist/index.cjs

-const require_src = require('./src-R301xi7y.cjs');
-
-exports.GET_IS_ASYNC = require_src.GET_IS_ASYNC;
-exports.QuansyncError = require_src.QuansyncError;
-exports.getIsAsync = require_src.getIsAsync;
-exports.quansync = require_src.quansync;
-exports.toGenerator = require_src.toGenerator;

dist/index.d.cts

-import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-P2bL9qIb.cjs";
-
-//#region src/index.d.ts
-declare const GET_IS_ASYNC: unique symbol;
-declare class QuansyncError extends Error {
-  constructor(message?: string);
-}
-/**
- * Creates a new Quansync function, a "superposition" between async and sync.
- */
-declare function quansync<Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
-declare function quansync<Return, Args extends any[] = []>(input: QuansyncGeneratorFn<Return, Args> | Promise<Return>, options?: QuansyncOptions): QuansyncFn<Return, Args>;
-/**
- * Converts a promise to a Quansync generator.
- */
-declare function toGenerator<T>(promise: Promise<T> | QuansyncGenerator<T> | T): QuansyncGenerator<T>;
-/**
- * @returns `true` if the current context is async, `false` otherwise.
- */
-declare const getIsAsync: QuansyncFn<boolean, []>;
-//#endregion
-export { GET_IS_ASYNC, QuansyncAwaitableGenerator, QuansyncError, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, getIsAsync, quansync, toGenerator };

dist/index.d.mts

-import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-DWHIQs0F.mjs";
-
-//#region src/index.d.ts
-declare const GET_IS_ASYNC: unique symbol;
-declare class QuansyncError extends Error {
-  constructor(message?: string);
-}
-/**
- * Creates a new Quansync function, a "superposition" between async and sync.
- */
-declare function quansync<Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
-declare function quansync<Return, Args extends any[] = []>(input: QuansyncGeneratorFn<Return, Args> | Promise<Return>, options?: QuansyncOptions): QuansyncFn<Return, Args>;
-/**
- * Converts a promise to a Quansync generator.
- */
-declare function toGenerator<T>(promise: Promise<T> | QuansyncGenerator<T> | T): QuansyncGenerator<T>;
-/**
- * @returns `true` if the current context is async, `false` otherwise.
- */
-declare const getIsAsync: QuansyncFn<boolean, []>;
-//#endregion
-export { GET_IS_ASYNC, QuansyncAwaitableGenerator, QuansyncError, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, getIsAsync, quansync, toGenerator };

dist/index.mjs

-import { a as toGenerator, i as quansync, n as QuansyncError, r as getIsAsync, t as GET_IS_ASYNC } from "./src-CCDg7b4L.mjs";
-
-export { GET_IS_ASYNC, QuansyncError, getIsAsync, quansync, toGenerator };

dist/macro.cjs

-const require_src = require('./src-R301xi7y.cjs');
-
-//#region src/macro.ts
-/**
-* This function is equivalent to `quansync` from main entry
-* but accepts a fake argument type of async functions.
-*
-* This requires to be used with the macro transformer `unplugin-quansync`.
-* Do NOT use it directly.
-*
-* @internal
-*/
-const quansync = require_src.quansync;
-
-//#endregion
-exports.quansync = quansync;

dist/macro.d.cts

-import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-P2bL9qIb.cjs";
-
-//#region src/macro.d.ts
-
-/**
- * This function is equivalent to `quansync` from main entry
- * but accepts a fake argument type of async functions.
- *
- * This requires to be used with the macro transformer `unplugin-quansync`.
- * Do NOT use it directly.
- *
- * @internal
- */
-declare const quansync: {
-  <Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
-  <Return, Args extends any[] = []>(input: Promise<Return> | QuansyncGeneratorFn<Return, Args> | ((...args: Args) => Return | Promise<Return>), options?: QuansyncOptions | undefined): QuansyncFn<Return, Args>;
-};
-//#endregion
-export { QuansyncAwaitableGenerator, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, quansync };

dist/macro.d.mts

-import { a as QuansyncInput, i as QuansyncGeneratorFn, n as QuansyncFn, o as QuansyncInputObject, r as QuansyncGenerator, s as QuansyncOptions, t as QuansyncAwaitableGenerator } from "./types-DWHIQs0F.mjs";
-
-//#region src/macro.d.ts
-
-/**
- * This function is equivalent to `quansync` from main entry
- * but accepts a fake argument type of async functions.
- *
- * This requires to be used with the macro transformer `unplugin-quansync`.
- * Do NOT use it directly.
- *
- * @internal
- */
-declare const quansync: {
-  <Return, Args extends any[] = []>(input: QuansyncInputObject<Return, Args>): QuansyncFn<Return, Args>;
-  <Return, Args extends any[] = []>(input: Promise<Return> | QuansyncGeneratorFn<Return, Args> | ((...args: Args) => Return | Promise<Return>), options?: QuansyncOptions | undefined): QuansyncFn<Return, Args>;
-};
-//#endregion
-export { QuansyncAwaitableGenerator, QuansyncFn, QuansyncGenerator, QuansyncGeneratorFn, QuansyncInput, QuansyncInputObject, QuansyncOptions, quansync };

dist/macro.mjs

-import { i as quansync$1 } from "./src-CCDg7b4L.mjs";
-
-//#region src/macro.ts
-/**
-* This function is equivalent to `quansync` from main entry
-* but accepts a fake argument type of async functions.
-*
-* This requires to be used with the macro transformer `unplugin-quansync`.
-* Do NOT use it directly.
-*
-* @internal
-*/
-const quansync = quansync$1;
-
-//#endregion
-export { quansync };

dist/src-CCDg7b4L.mjs

-//#region src/index.ts
-const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
-var QuansyncError = class extends Error {
-	constructor(message = "Unexpected promise in sync context") {
-		super(message);
-		this.name = "QuansyncError";
-	}
-};
-function isThenable(value) {
-	return value && typeof value === "object" && typeof value.then === "function";
-}
-function isQuansyncGenerator(value) {
-	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
-}
-function fromObject(options) {
-	const generator = function* (...args) {
-		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
-		return options.sync.apply(this, args);
-	};
-	function fn(...args) {
-		const iter = generator.apply(this, args);
-		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
-		iter.__quansync = true;
-		return iter;
-	}
-	fn.sync = options.sync;
-	fn.async = options.async;
-	return fn;
-}
-function fromPromise(promise) {
-	return fromObject({
-		async: () => Promise.resolve(promise),
-		sync: () => {
-			if (isThenable(promise)) throw new QuansyncError();
-			return promise;
-		}
-	});
-}
-function unwrapYield(value, isAsync) {
-	if (value === GET_IS_ASYNC) return isAsync;
-	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
-	if (!isAsync && isThenable(value)) throw new QuansyncError();
-	return value;
-}
-const DEFAULT_ON_YIELD = (value) => value;
-function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(unwrapYield(onYield(current.value, false)));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return unwrapYield(current.value);
-}
-async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(await unwrapYield(onYield(current.value, true), true));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return current.value;
-}
-function fromGeneratorFn(generatorFn, options) {
-	return fromObject({
-		name: generatorFn.name,
-		async(...args) {
-			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
-		},
-		sync(...args) {
-			return iterateSync(generatorFn.apply(this, args), options?.onYield);
-		}
-	});
-}
-function quansync(input, options) {
-	if (isThenable(input)) return fromPromise(input);
-	if (typeof input === "function") return fromGeneratorFn(input, options);
-	else return fromObject(input);
-}
-/**
-* Converts a promise to a Quansync generator.
-*/
-function toGenerator(promise) {
-	if (isQuansyncGenerator(promise)) return promise;
-	return fromPromise(promise)();
-}
-/**
-* @returns `true` if the current context is async, `false` otherwise.
-*/
-const getIsAsync = quansync({
-	async: () => Promise.resolve(true),
-	sync: () => false
-});
-
-//#endregion
-export { toGenerator as a, quansync as i, QuansyncError as n, getIsAsync as r, GET_IS_ASYNC as t };

dist/src-R301xi7y.cjs

-
-//#region src/index.ts
-const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
-var QuansyncError = class extends Error {
-	constructor(message = "Unexpected promise in sync context") {
-		super(message);
-		this.name = "QuansyncError";
-	}
-};
-function isThenable(value) {
-	return value && typeof value === "object" && typeof value.then === "function";
-}
-function isQuansyncGenerator(value) {
-	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
-}
-function fromObject(options) {
-	const generator = function* (...args) {
-		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
-		return options.sync.apply(this, args);
-	};
-	function fn(...args) {
-		const iter = generator.apply(this, args);
-		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
-		iter.__quansync = true;
-		return iter;
-	}
-	fn.sync = options.sync;
-	fn.async = options.async;
-	return fn;
-}
-function fromPromise(promise) {
-	return fromObject({
-		async: () => Promise.resolve(promise),
-		sync: () => {
-			if (isThenable(promise)) throw new QuansyncError();
-			return promise;
-		}
-	});
-}
-function unwrapYield(value, isAsync) {
-	if (value === GET_IS_ASYNC) return isAsync;
-	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
-	if (!isAsync && isThenable(value)) throw new QuansyncError();
-	return value;
-}
-const DEFAULT_ON_YIELD = (value) => value;
-function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(unwrapYield(onYield(current.value, false)));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return unwrapYield(current.value);
-}
-async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(await unwrapYield(onYield(current.value, true), true));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return current.value;
-}
-function fromGeneratorFn(generatorFn, options) {
-	return fromObject({
-		name: generatorFn.name,
-		async(...args) {
-			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
-		},
-		sync(...args) {
-			return iterateSync(generatorFn.apply(this, args), options?.onYield);
-		}
-	});
-}
-function quansync(input, options) {
-	if (isThenable(input)) return fromPromise(input);
-	if (typeof input === "function") return fromGeneratorFn(input, options);
-	else return fromObject(input);
-}
-/**
-* Converts a promise to a Quansync generator.
-*/
-function toGenerator(promise) {
-	if (isQuansyncGenerator(promise)) return promise;
-	return fromPromise(promise)();
-}
-/**
-* @returns `true` if the current context is async, `false` otherwise.
-*/
-const getIsAsync = quansync({
-	async: () => Promise.resolve(true),
-	sync: () => false
-});
-
-//#endregion
-Object.defineProperty(exports, 'GET_IS_ASYNC', {
-  enumerable: true,
-  get: function () {
-    return GET_IS_ASYNC;
-  }
-});
-Object.defineProperty(exports, 'QuansyncError', {
-  enumerable: true,
-  get: function () {
-    return QuansyncError;
-  }
-});
-Object.defineProperty(exports, 'getIsAsync', {
-  enumerable: true,
-  get: function () {
-    return getIsAsync;
-  }
-});
-Object.defineProperty(exports, 'quansync', {
-  enumerable: true,
-  get: function () {
-    return quansync;
-  }
-});
-Object.defineProperty(exports, 'toGenerator', {
-  enumerable: true,
-  get: function () {
-    return toGenerator;
-  }
-});

dist/types-DWHIQs0F.d.mts

-//#region src/types.d.ts
-interface QuansyncOptions {
-  onYield?: (value: any, isAsync: boolean) => any;
-}
-interface QuansyncInputObject<Return, Args extends any[]> extends QuansyncOptions {
-  name?: string;
-  sync: (...args: Args) => Return;
-  async: (...args: Args) => Promise<Return>;
-}
-type QuansyncGeneratorFn<Return, Args extends any[]> = ((...args: Args) => QuansyncGenerator<Return>);
-type QuansyncInput<Return, Args extends any[]> = QuansyncInputObject<Return, Args> | QuansyncGeneratorFn<Return, Args>;
-type QuansyncGenerator<Return = any, Yield = unknown> = Generator<Yield, Return, Awaited<Yield>> & {
-  __quansync?: true;
-};
-type QuansyncAwaitableGenerator<Return = any, Yield = unknown> = QuansyncGenerator<Return, Yield> & PromiseLike<Return>;
-/**
- * "Superposition" function that can be consumed in both sync and async contexts.
- */
-type QuansyncFn<Return = any, Args extends any[] = []> = ((...args: Args) => QuansyncAwaitableGenerator<Return>) & {
-  /**
-   * **Warning**: The `async` and `sync` methods will be lost after invoked.
-   */
-  bind: <T, A extends any[], B extends any[]>(this: (this: T, ...args: [...A, ...B]) => QuansyncAwaitableGenerator<Return>, thisArg: T, ...args: A) => ((...args: B) => QuansyncAwaitableGenerator<Return>);
-  sync: (...args: Args) => Return;
-  async: (...args: Args) => Promise<Return>;
-};
-//#endregion
-export { QuansyncInput as a, QuansyncGeneratorFn as i, QuansyncFn as n, QuansyncInputObject as o, QuansyncGenerator as r, QuansyncOptions as s, QuansyncAwaitableGenerator as t };

dist/types-P2bL9qIb.d.cts

-//#region src/types.d.ts
-interface QuansyncOptions {
-  onYield?: (value: any, isAsync: boolean) => any;
-}
-interface QuansyncInputObject<Return, Args extends any[]> extends QuansyncOptions {
-  name?: string;
-  sync: (...args: Args) => Return;
-  async: (...args: Args) => Promise<Return>;
-}
-type QuansyncGeneratorFn<Return, Args extends any[]> = ((...args: Args) => QuansyncGenerator<Return>);
-type QuansyncInput<Return, Args extends any[]> = QuansyncInputObject<Return, Args> | QuansyncGeneratorFn<Return, Args>;
-type QuansyncGenerator<Return = any, Yield = unknown> = Generator<Yield, Return, Awaited<Yield>> & {
-  __quansync?: true;
-};
-type QuansyncAwaitableGenerator<Return = any, Yield = unknown> = QuansyncGenerator<Return, Yield> & PromiseLike<Return>;
-/**
- * "Superposition" function that can be consumed in both sync and async contexts.
- */
-type QuansyncFn<Return = any, Args extends any[] = []> = ((...args: Args) => QuansyncAwaitableGenerator<Return>) & {
-  /**
-   * **Warning**: The `async` and `sync` methods will be lost after invoked.
-   */
-  bind: <T, A extends any[], B extends any[]>(this: (this: T, ...args: [...A, ...B]) => QuansyncAwaitableGenerator<Return>, thisArg: T, ...args: A) => ((...args: B) => QuansyncAwaitableGenerator<Return>);
-  sync: (...args: Args) => Return;
-  async: (...args: Args) => Promise<Return>;
-};
-//#endregion
-export { QuansyncInput as a, QuansyncGeneratorFn as i, QuansyncFn as n, QuansyncInputObject as o, QuansyncGenerator as r, QuansyncOptions as s, QuansyncAwaitableGenerator as t };

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Number of low quality alerts

0

-100%

Worsened metrics

Total package byte prevSize

14891

-35.11%

Number of package files

9

-40%

Lines of code

171

-31.33%

No dependency changes