effect-app 4.0.0-beta.2 → 4.0.0-beta.20

package/src/utils.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-import { Effect, Exit, Fiber, Option, Record } from "effect"
+import { Cause, Effect, Exit, Fiber, Option, Record } from "effect"
 import { dual } from "effect/Function"
-import { isFunction } from "effect/Predicate"
+import { isFunction, isObject } from "effect/Predicate"
 import * as Result from "effect/Result"
 import type { GetFieldType, NumericDictionary, PropertyPath } from "lodash"
 import { identity, pipe } from "./Function.js"
@@ -924,8 +924,8 @@ export const runtimeFiberAsPromise = <A, E>(fiber: Fiber.Fiber<A, E>, signal?: A
       if (Exit.isSuccess(exit)) {
         resolve(exit.value)
       } else {
-        // errors really should be of type Error, so we wrap in FiberFailure just as default Effect
-        reject(exit.cause)
+        // eslint-disable-next-line
+        reject(Cause.squash(exit.cause))
       }
     })
   )
@@ -950,3 +950,25 @@ export type UnionToTuples<T, U = T> = [T] extends [never] ? []
       | [T, ...UnionToTuples<Exclude<U, T>>]
       | UnionToTuples<Exclude<U, T>>
   : []
+
+const genConstructor = (function*() {}).constructor
+
+/**
+ * @example
+ * ```ts
+ * import { Utils } from "effect"
+ *
+ * function* generatorFn() {
+ *   yield 1
+ *   yield 2
+ * }
+ *
+ * console.log(Utils.isGeneratorFunction(generatorFn)) // true
+ * console.log(Utils.isGeneratorFunction(() => {})) // false
+ * ```
+ *
+ * @category predicates
+ * @since 3.11.0
+ */
+export const isGeneratorFunction = (u: unknown): u is (...args: Array<any>) => Generator<any, any, any> =>
+  isObject(u) && u.constructor === genConstructor

package/test/dist/moreStrings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moreStrings.test.d.ts","sourceRoot":"","sources":["../moreStrings.test.ts"],"names":[],"mappings":""}

package/test/dist/rpc.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

package/test/moreStrings.test.ts

@@ -0,0 +1,17 @@
+import { S } from "effect-app"
+import * as fc from "fast-check"
+import { urlAlphabet } from "nanoid"
+import { test } from "vitest"
+
+const nanoidAlphabet = new Set(urlAlphabet)
+
+const isNanoId = (value: string) => value.length === 21 && Array.from(value).every((char) => nanoidAlphabet.has(char))
+
+test("StringId arbitrary generates nanoid-shaped values", () => {
+  fc.assert(
+    fc.property(S.toArbitrary(S.StringId), (value) => {
+      expect(isNanoId(value)).toBe(true)
+      expect(S.is(S.StringId)(value)).toBe(true)
+    })
+  )
+})

package/test/schema.test.ts

@@ -1,6 +1,6 @@
 // import { generateFromArbitrary } from "@effect-app/infra/test"
 import { Array, S } from "effect-app"
-import { test } from "vitest"
+import { expect, test } from "vitest"
 
 const A = S.Struct({ a: S.NonEmptyString255, email: S.NullOr(S.Email) })
 test("works", () => {
@@ -23,3 +23,34 @@ test("literal default works", () => {
   const s2 = S.Struct({ l: l2.withDefault })
   expect(s2.makeUnsafe({}).l).toBe("b")
 })
+
+test("tagged union derives tag map and tags from v4 literal ast", () => {
+  const schema = S.TaggedUnion(
+    S.TaggedStruct("A", { a: S.String }),
+    S.TaggedStruct("B", { b: S.Number }),
+    S.TaggedStruct("C", { c: S.Boolean })
+  )
+  const caseA = schema.tagMap["A"]
+  const caseB = schema.tagMap["B"]
+  const caseC = schema.tagMap["C"]
+  const isAOrB = schema.isAnyOf("A", "B")
+
+  expect(caseA.fields._tag.ast.literal).toBe("A")
+  expect(caseB.fields._tag.ast.literal).toBe("B")
+  expect(caseC.fields._tag.ast.literal).toBe("C")
+  expect(S.decodeSync(schema.tags)("A")).toBe("A")
+  expect(S.decodeSync(schema.tags)("B")).toBe("B")
+  expect(S.decodeSync(schema.tags)("C")).toBe("C")
+  expect(() => S.decodeUnknownSync(schema.tags)("D")).toThrow()
+
+  expect(schema.isA.A({ _tag: "A", a: "ok" })).toBe(true)
+  expect(schema.isA.A({ _tag: "B", b: 1 })).toBe(false)
+  expect(schema.isA.B({ _tag: "B", b: 1 })).toBe(true)
+  expect(schema.isA.B({ _tag: "A", a: "ok" })).toBe(false)
+  expect(schema.isA.C({ _tag: "C", c: true })).toBe(true)
+  expect(schema.isA.C({ _tag: "A", a: "ok" })).toBe(false)
+
+  expect(isAOrB({ _tag: "A", a: "ok" })).toBe(true)
+  expect(isAOrB({ _tag: "B", b: 1 })).toBe(true)
+  expect(isAOrB({ _tag: "C", c: true })).toBe(false)
+})

package/dist/Struct.d.ts

@@ -1,44 +0,0 @@
-import type { Types } from "effect";
-export * from "effect/Struct";
-/**
- * Create a new object by picking properties of an existing object.
- *
- * @example
- * import { pick } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
- * assert.deepStrictEqual(pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export declare const pick: {
-    <Keys extends Array<PropertyKey>>(keys: Keys): <S extends {
-        [K in Keys[number]]?: any;
-    }>(s: S) => Types.MatchRecord<S, {
-        [K in Keys[number]]?: S[K];
-    }, Pick<S, Keys[number]>>;
-    <S extends object, Keys extends Array<keyof S>>(s: S, keys: Keys): Types.MatchRecord<S, {
-        [K in Keys[number]]?: S[K];
-    }, Pick<S, Keys[number]>>;
-};
-export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
-/**
- * Create a new object by omitting properties of an existing object.
- *
- * @example
- * import { omit } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
- * assert.deepStrictEqual(omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export declare const omit: {
-    <Keys extends Array<PropertyKey>>(keys: Keys): <S extends {
-        [K in Keys[number]]?: any;
-    }>(s: S) => DistributiveOmit<S, Keys[number]>;
-    <S extends object, Keys extends Array<keyof S>>(s: S, keys: Keys): DistributiveOmit<S, Keys[number]>;
-};
-//# sourceMappingURL=Struct.d.ts.map

package/dist/Struct.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Struct.d.ts","sourceRoot":"","sources":["../src/Struct.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAGnC,cAAc,eAAe,CAAA;AAE7B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,IAAI,SAAS,KAAK,CAAC,WAAW,CAAC,EAC9B,IAAI,EAAE,IAAI,GACT,CAAC,CAAC,SAAS;SAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG;KAAE,EACzC,CAAC,EAAE,CAAC,KACD,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE;SAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAAE,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAChF,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,EAC5C,CAAC,EAAE,CAAC,EACJ,IAAI,EAAE,IAAI,GACT,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE;SAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAAE,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACjE,CAAA;AAEf,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7E,KAAK,CAAA;AAET;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,IAAI,SAAS,KAAK,CAAC,WAAW,CAAC,EAC9B,IAAI,EAAE,IAAI,GACT,CAAC,CAAC,SAAS;SAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG;KAAE,EAAE,CAAC,EAAE,CAAC,KAAK,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;IACvF,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,EAC5C,CAAC,EAAE,CAAC,EACJ,IAAI,EAAE,IAAI,GACT,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;CAChB,CAAA"}

package/dist/Struct.js

@@ -1,29 +0,0 @@
-import * as Struct from "effect/Struct";
-export * from "effect/Struct";
-/**
- * Create a new object by picking properties of an existing object.
- *
- * @example
- * import { pick } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
- * assert.deepStrictEqual(pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export const pick = Struct.pick;
-/**
- * Create a new object by omitting properties of an existing object.
- *
- * @example
- * import { omit } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
- * assert.deepStrictEqual(omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export const omit = Struct.omit;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RydWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1N0cnVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssTUFBTSxNQUFNLGVBQWUsQ0FBQTtBQUV2QyxjQUFjLGVBQWUsQ0FBQTtBQUU3Qjs7Ozs7Ozs7Ozs7R0FXRztBQUNILE1BQU0sQ0FBQyxNQUFNLElBQUksR0FVYixNQUFNLENBQUMsSUFBSSxDQUFBO0FBS2Y7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBUWIsTUFBTSxDQUFDLElBQVcsQ0FBQSJ9

package/src/Struct.ts

@@ -1,54 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Types } from "effect"
-import * as Struct from "effect/Struct"
-
-export * from "effect/Struct"
-
-/**
- * Create a new object by picking properties of an existing object.
- *
- * @example
- * import { pick } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, pick("a", "b")), { a: "a", b: 1 })
- * assert.deepStrictEqual(pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export const pick: {
-  <Keys extends Array<PropertyKey>>(
-    keys: Keys
-  ): <S extends { [K in Keys[number]]?: any }>(
-    s: S
-  ) => Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
-  <S extends object, Keys extends Array<keyof S>>(
-    s: S,
-    keys: Keys
-  ): Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
-} = Struct.pick
-
-export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K>
-  : never
-
-/**
- * Create a new object by omitting properties of an existing object.
- *
- * @example
- * import { omit } from "effect/Struct"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, omit("c")), { a: "a", b: 1 })
- * assert.deepStrictEqual(omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
- *
- * @since 2.0.0
- */
-export const omit: {
-  <Keys extends Array<PropertyKey>>(
-    keys: Keys
-  ): <S extends { [K in Keys[number]]?: any }>(s: S) => DistributiveOmit<S, Keys[number]>
-  <S extends object, Keys extends Array<keyof S>>(
-    s: S,
-    keys: Keys
-  ): DistributiveOmit<S, Keys[number]>
-} = Struct.omit as any