effect-app 0.152.0

package/_src/schema/shared.ts.bak

@@ -0,0 +1,334 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { pipe } from "@effect-app/core/Function"
+import type { Refinement } from "@effect-app/core/Function"
+import type {
+  ApiOf,
+  ApiSelfType,
+  DefaultSchema,
+  Field,
+  NonEmptyString,
+  NonEmptyString50Brand,
+  Parser,
+  SchemaDefaultSchema,
+  SchemaUPI,
+  Utils
+} from "effect-app/schema"
+import {
+  annotate,
+  brand,
+  defaultProp,
+  EParserFor,
+  extendWithUtils,
+  extendWithUtilsAnd,
+  leafE,
+  makeAnnotation,
+  named,
+  nonEmptyStringFromString,
+  refine
+} from "effect-app/schema"
+import type * as FC from "fast-check"
+import { customRandom, nanoid, urlAlphabet } from "nanoid"
+import validator from "validator"
+import { curriedMagix } from "../Function.js"
+import type { NonEmptyString255Brand, To, UnionBrand } from "./_schema.js"
+import {
+  Arbitrary,
+  arbitrary,
+  customE,
+  Email as Email_,
+  fakerArb,
+  fromString,
+  makeConstrainedFromString,
+  NonEmptyString255,
+  PositiveInt,
+  string,
+  stringNumber,
+  withDefaults
+} from "./_schema.js"
+
+export const stringPositiveIntIdentifier = makeAnnotation<{}>()
+
+export const StringPositiveInt: DefaultSchema<unknown, PositiveInt, PositiveInt, string, {}> = pipe(
+  stringNumber[">>>"](PositiveInt),
+  withDefaults,
+  annotate(stringPositiveIntIdentifier, {})
+)
+export type StringPositiveInt = PositiveInt
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export interface Min3String255Brand extends NonEmptyString255Brand {
+  readonly Min3String255: unique symbol
+}
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export type Min3String255 = string & Min3String255Brand
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export const Min3String255FromString = pipe(
+  makeConstrainedFromString<Min3String255>(3, 255),
+  arbitrary((FC) =>
+    FC
+      .lorem({ mode: "words", maxCount: 2 })
+      .filter((x) => x.length < 255 && x.length >= 3)
+      .map((x) => x as Min3String255)
+  ),
+  // arbitrary removes brand benefit
+  brand<Min3String255>()
+)
+
+/**
+ * A string that is at least 3 character long and a maximum of 255.
+ */
+export const Min3String255 = extendWithUtils(
+  pipe(string[">>>"](Min3String255FromString), brand<Min3String255>())
+)
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export interface StringIdBrand extends NonEmptyString50Brand, Min3String255Brand {
+  readonly StringId: unique symbol
+}
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export type StringId = string & StringIdBrand
+
+const MIN_LENGTH = 6
+const MAX_LENGTH = 50
+const size = 21
+const length = 10 * size
+export const stringIdFromString = pipe(
+  makeConstrainedFromString<StringId>(MIN_LENGTH, MAX_LENGTH),
+  arbitrary((FC) =>
+    FC
+      .uint8Array({ minLength: length, maxLength: length })
+      .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))() as StringId)
+  ),
+  // arbitrary removes the benefit of Brand,
+  brand<StringId>()
+)
+
+/**
+ * A string that is at least 6 characters long and a maximum of 50.
+ */
+export interface StringIdSchema extends
+  SchemaDefaultSchema<
+    unknown,
+    StringId,
+    string,
+    string,
+    ApiSelfType<StringId>
+  >
+{}
+const StringIdSchema: StringIdSchema = string[">>>"](stringIdFromString).pipe(
+  brand<StringId>()
+)
+const makeStringId = (): StringId => nanoid() as unknown as StringId
+export const StringId = extendWithUtilsAnd(StringIdSchema, () => ({
+  make: makeStringId,
+  withDefault: defaultProp(StringIdSchema, makeStringId)
+}))
+
+const stringIdArb = Arbitrary.for(StringId)
+
+export const prefixedStringIdUnsafe = (prefix: string) => StringId(prefix + StringId.make())
+
+export const prefixedStringIdUnsafeThunk = (prefix: string) => () => prefixedStringIdUnsafe(prefix)
+
+export interface PrefixedStringIdSchema<
+  Brand extends StringId,
+  Prefix extends string,
+  Separator extends string
+> extends
+  SchemaWithUtils<
+    SchemaDefaultSchema<unknown, Brand, string, string, ApiSelfType<StringId>>
+  >,
+  PrefixedStringUtils<Brand, Prefix, Separator>
+{}
+
+export type SchemaWithUtils<Schema extends SchemaUPI> = Schema & Utils<Schema>
+
+export function prefixedStringId<Brand extends StringId>() {
+  return <Prefix extends string, Separator extends string = "-">(
+    prefix: Prefix,
+    name: string,
+    separator?: Separator
+  ): PrefixedStringIdSchema<Brand, Prefix, Separator> => {
+    type FullPrefix = `${Prefix}${Separator}`
+    // type PrefixedId = `${FullPrefix}${string}`
+
+    const pref = `${prefix}${separator ?? "-"}` as FullPrefix
+    const refinement = (x: StringId): x is Brand => x.startsWith(pref)
+    const fromString = pipe(
+      stringIdFromString,
+      refine(
+        refinement,
+        (n) => leafE(customE(n, `a StringId prefixed with '${pref}'`))
+      ),
+      arbitrary((FC) =>
+        stringIdArb(FC).map(
+          (x) => (pref + x.substring(0, MAX_LENGTH - pref.length)) as Brand
+        )
+      )
+    )
+
+    const schema = string[">>>"](fromString).pipe(named(name)).pipe(brand<Brand>())
+    const make = () => (pref + StringId.make()) as Brand
+
+    return extendWithUtilsAnd(
+      schema,
+      (ex): PrefixedStringUtils<Brand, Prefix, Separator> => ({
+        EParser: EParserFor(ex),
+        make,
+        /**
+         * Automatically adds the prefix.
+         */
+        unsafeFrom: (str: string) => ex(pref + str),
+        /**
+         * Must provide a literal string starting with prefix.
+         */
+        prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => ex(str),
+        prefix,
+        eq: Equivalence.string as Equivalence<Brand>,
+        withDefault: defaultProp(schema, make)
+      })
+    )
+  }
+}
+
+export const brandedStringId = <Brand extends StringId>() =>
+  extendWithUtilsAnd(StringId.pipe(brand<Brand>()), (s) => {
+    const make = (): Brand => StringId.make() as unknown as Brand
+
+    return ({
+      EParser: EParserFor(s),
+      make,
+      eq: Equivalence.string as Equivalence<Brand>,
+      withDefault: defaultProp(s, make)
+    })
+  })
+
+export interface PrefixedStringUtils<
+  Brand extends StringId,
+  Prefix extends string,
+  Separator extends string
+> {
+  readonly EParser: Parser.Parser<string, any, Brand>
+  readonly make: () => Brand
+  readonly unsafeFrom: (str: string) => Brand
+  prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => Brand
+  readonly prefix: Prefix
+  eq: Equivalence<Brand>
+  readonly withDefault: Field<
+    SchemaDefaultSchema<unknown, Brand, string, string, ApiOf<PrefixedStringIdSchema<Brand, Prefix, Separator>>>,
+    "required",
+    None<any>,
+    Some<["constructor", () => Brand]>
+  >
+}
+
+export interface UrlBrand {
+  readonly Url: unique symbol
+}
+
+export type Url = NonEmptyString & UrlBrand
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const UrlFromStringIdentifier = makeAnnotation<{}>()
+
+const isUrl: Refinement<string, Url> = (s: string): s is Url => {
+  return validator.default.isURL(s, { require_tld: false })
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const UrlFromString: DefaultSchema<string, Url, string, string, {}> = pipe(
+  fromString,
+  arbitrary((FC) => FC.webUrl()),
+  refine(isUrl, (n) => leafE(customE(n, "a valid Web URL according to | RFC 3986 and | WHATWG URL Standard"))),
+  brand<Url>(),
+  annotate(UrlFromStringIdentifier, {})
+)
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const UrlIdentifier = makeAnnotation<{}>()
+
+export const Url = extendWithUtils(
+  pipe(
+    string[">>>"](UrlFromString),
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    arbitrary((FC) => fakerArb((faker) => faker.internet.url)(FC) as FC.Arbitrary<Url>),
+    brand<Url>(),
+    annotate(UrlIdentifier, {})
+  )
+)
+
+export const avatarUrl = pipe(string[">>>"](nonEmptyStringFromString))
+  .pipe(
+    arbitrary(
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      (FC) => fakerArb((faker) => faker.internet.avatar)(FC) as FC.Arbitrary<Url>
+    )
+  )
+  .pipe(brand<avatarUrl>())
+
+export type avatarUrl = NonEmptyString & UnionBrand
+
+export const customUrlFromString = (pool: readonly Url[]) =>
+  pipe(
+    UrlFromString,
+    arbitrary((FC) => FC.oneof(...pool.map(FC.constant))),
+    brand<Url>()
+  )
+
+export const customUrl = (pool: readonly Url[]) => pipe(string[">>>"](customUrlFromString(pool)), brand<Url>())
+
+// for now be less restrictive about the PhoneNumber
+const PhoneNumber_ = StringId
+export const PhoneNumber = PhoneNumber_
+  .pipe(
+    arbitrary((FC) =>
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      fakerArb((faker) => faker.phone.number)(FC).map((x) => x as StringId)
+    )
+  )
+  .pipe(brand<PhoneNumber>())
+
+export type PhoneNumber = StringId & UnionBrand
+
+const endsWith = curriedMagix(
+  (e: Email) => (s: string) => e.toLowerCase().endsWith(s.toLowerCase())
+)
+const Email__ = Object.assign(
+  extendWithUtils(
+    Email_
+      .pipe(
+        arbitrary((FC) =>
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          fakerArb((faker) => faker.internet.email)(FC).map((x) => x as Email)
+        )
+      )
+      .pipe(brand<Email>())
+  ),
+  {
+    eq: { equals: (a: Email, b: Email) => a.toLowerCase() === b.toLowerCase() },
+    endsWith,
+    toDomain: (email: Email) => NonEmptyString255(email.split("@")[1]),
+    isDomain: curriedMagix(
+      (e: Email) => (domain: string) => endsWith._("@" + domain, e)
+    ),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    toDisplayName: (e: Email) => e.split("@")[0]
+  }
+)
+type EmailSchema__ = typeof Email__
+export interface EmailSchema extends EmailSchema__ {}
+export const Email: EmailSchema = Email__
+export type Email = To<typeof Email_> & {
+  split: (separator: "@") => [NonEmptyString255, NonEmptyString255]
+}

package/_src/schema.test.ts

@@ -0,0 +1,3 @@
+test("works", () => {
+  console.log(StringId.make())
+})

package/_src/schema.ts

@@ -0,0 +1,37 @@
+import { isValidEmail, isValidPhone } from "@effect-app/core/validation"
+import { type A, type Email as EmailT, fromBrand, nominal, type PhoneNumber as PhoneNumberT } from "@effect-app/schema"
+import { fakerArb } from "./faker.js"
+
+export const Email = S
+  .string
+  .pipe(
+    S.filter(isValidEmail, {
+      title: "Email",
+      description: "an email according to RFC 5322",
+      jsonSchema: { format: "email" },
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      arbitrary: (): A.Arbitrary<string> => fakerArb((faker) => faker.internet.exampleEmail)
+    }),
+    fromBrand(nominal<Email>(), { jsonSchema: {} }),
+    S.withDefaults
+  )
+
+export type Email = EmailT
+
+export const PhoneNumber = S
+  .string
+  .pipe(
+    S.filter(isValidPhone, {
+      title: "PhoneNumber",
+      description: "a phone number with at least 7 digits",
+      jsonSchema: { format: "phone" },
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      arbitrary: (): A.Arbitrary<string> => fakerArb((faker) => faker.phone.number)
+    }),
+    fromBrand(nominal<PhoneNumber>(), { jsonSchema: {} }),
+    S.withDefaults
+  )
+
+export type PhoneNumber = PhoneNumberT
+
+export * from "@effect-app/schema"

package/_src/service.ts

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+/**
+ * We're doing the long way around here with assignTag, TagBase & TagBaseTagged,
+ * because there's a typescript compiler issue where it will complain about Equal.symbol, and Hash.symbol not being accessible.
+ * https://github.com/microsoft/TypeScript/issues/52644
+ */
+
+import type { TagTypeId as TagTypeIdOriginal } from "effect/Context"
+
+export const ServiceTag = Symbol()
+export type ServiceTag = typeof ServiceTag
+
+export abstract class PhantomTypeParameter<Identifier extends keyof any, InstantiatedType> {
+  protected abstract readonly [ServiceTag]: {
+    readonly [NameP in Identifier]: (_: InstantiatedType) => InstantiatedType
+  }
+}
+
+/**
+ * @tsplus type ServiceTagged
+ */
+export abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {}
+
+/**
+ * @tsplus static ServiceTagged make
+ */
+export function makeService<T extends ServiceTagged<any>>(_: Omit<T, ServiceTag>) {
+  return _ as T
+}
+
+/**
+ * @tsplus fluent effect/data/Context/Tag make
+ */
+export function make<T extends ServiceTagged<any>, I = T>(_: Tag<I, T>, t: Omit<T, ServiceTag>) {
+  return t as T
+}
+
+export const TagTypeId: TagTypeIdOriginal = Symbol.for("effect/Context/Tag") as unknown as TagTypeIdOriginal
+export type TagTypeId = typeof TagTypeId
+
+let i = 0
+const randomId = () => "unknown-service-" + i++
+
+export function assignTag<Id, Service = Id>(key?: string) {
+  return <S extends object>(cls: S): S & Tag<Id, Service> => {
+    const tag = GenericTag<Id, Service>(key ?? randomId())
+    const t = Object.assign(cls, Object.getPrototypeOf(tag), tag)
+    const limit = Error.stackTraceLimit
+    Error.stackTraceLimit = 4 // TODO
+    const creationError = new Error()
+    Error.stackTraceLimit = limit
+    // the stack is used to get the location of the tag definition, if a service is not found in the registry
+    Object.defineProperty(t, "stack", {
+      get() {
+        // remove one line as assignTag is generally used inside a class constructor function
+        return creationError.stack?.split("\n").slice(1).join("\n")
+      }
+    })
+    return t
+  }
+}
+
+export function TagClass<Id, ServiceImpl, Service = Id>(key?: string) {
+  const c: { new(service: ServiceImpl): Readonly<ServiceImpl> } = class {
+    constructor(service: ServiceImpl) {
+      Object.assign(this, service)
+    }
+    // static readonly Id: Id
+  } as any
+
+  return assignTag<Id, Service>(key)(c)
+}
+
+export const TagClassMake = <Id, Service = Id>() =>
+<ServiceImpl, R, E>(
+  make: Effect<ServiceImpl, E, R>,
+  key?: string
+) => {
+  const c: {
+    new(service: ServiceImpl): Readonly<ServiceImpl>
+    toLayer: () => Layer<Service, E, R>
+    toLayerScoped: () => Layer<Service, E, Exclude<R, Scope>>
+  } = class {
+    constructor(service: ServiceImpl) {
+      Object.assign(this, service)
+    }
+    // works around an issue where defining layer on the class messes up and causes the Tag to infer to `any, any` :/
+    static toLayer() {
+      return make.toLayer(this as any)
+    }
+
+    static toLayerScoped() {
+      return make.toLayerScoped(this as any)
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any
+
+  return assignTag<Id, Service>(key)(c)
+}
+
+export function TagClassLegacy<Id, Service = Id>(key?: string) {
+  abstract class TagClassLegacy {}
+
+  return assignTag<Id, Service>(key)(TagClassLegacy)
+}
+
+/** @deprecated use `Id` of TagClass for unique id */
+export function ServiceTaggedClass<Id, Service = Id>() {
+  return <Key extends PropertyKey>(_: Key) => {
+    abstract class ServiceTaggedClassC {
+      static make = (t: Omit<Service, Key>) => {
+        return t as Service
+      }
+    }
+
+    return assignTag<Id, Service>()(ServiceTaggedClassC)
+  }
+}

package/_src/utils.ts

@@ -0,0 +1 @@
+export * from "@effect-app/core/utils"

package/dist/Config/SecretURL.d.ts

@@ -0,0 +1,82 @@
+import { Config } from "effect/Config";
+/**
+ * @since 1.0.0
+ */
+import type * as Chunk from "effect/Chunk";
+import type * as Equal from "effect/Equal";
+import type { SecretTypeId } from "effect/Secret";
+/**
+ * @tsplus type SecretURL
+ * @since 1.0.0
+ * @category models
+ */
+export interface SecretURL extends SecretURL.Proto, Equal.Equal {
+    /** @internal */
+    readonly raw: Array<number>;
+}
+/**
+ * @tsplus type SecretURL.Ops
+ */
+export interface SecretURLOps {
+}
+export declare const SecretURL: SecretURLOps;
+/**
+ * @since 1.0.0
+ */
+export declare namespace SecretURL {
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    interface Proto {
+        readonly [SecretTypeId]: SecretTypeId;
+    }
+}
+/**
+ * @tsplus static SecretURL.Ops isSecretURL
+ * @since 1.0.0
+ * @category refinements
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const isSecretURL: (u: unknown) => u is SecretURL;
+/**
+ * @tsplus static SecretURL.Ops make
+ * @since 1.0.0
+ * @category constructors
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const make: (bytes: Array<number>) => SecretURL;
+/**
+ * @tsplus static SecretURL.Ops fromChunk
+ * @since 1.0.0
+ * @category constructors
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const fromChunk: (chunk: Chunk.Chunk<string>) => SecretURL;
+/**
+ * @tsplus static SecretURL.Ops fromString
+ * @since 1.0.0
+ * @category constructors
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const fromString: (text: string) => SecretURL;
+/**
+ * @tsplus getter SecretURL value
+ * @since 1.0.0
+ * @category getters
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const value: (self: SecretURL) => string;
+/**
+ * @tsplus fluent SecretURL unsafeWipe
+ * @since 1.0.0
+ * @category unsafe
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const unsafeWipe: (self: SecretURL) => void;
+/**
+ * @tsplus static effect/io/Config.Ops secretURL
+ * @tsplus location "@effect-app/prelude/Config/SecretURL"
+ */
+export declare const secretURL: (name?: string) => Config<SecretURL>;
+//# sourceMappingURL=SecretURL.d.ts.map

package/dist/Config/SecretURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecretURL.d.ts","sourceRoot":"","sources":["../../_src/Config/SecretURL.ts"],"names":[],"mappings":";AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAejD;;;;GAIG;AACH,MAAM,WAAW,SAAU,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK;IAC7D,gBAAgB;IAChB,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;CAAG;AAEhC,eAAO,MAAM,SAAS,EAAE,YAAiB,CAAA;AAEzC;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC;;;OAGG;IACH,UAAiB,KAAK;QACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;KACtC;CACF;;;;;;;AAOD,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,SAAgC,CAAA;;;;;;;AAO/E,eAAO,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,SAAyB,CAAA;;;;;;;AAOtE,eAAO,MAAM,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,SAA8B,CAAA;;;;;;;AAOtF,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAA+B,CAAA;;;;;;;AAO1E,eAAO,MAAM,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAuB,CAAA;;;;;;;AAOhE,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAA0B,CAAA;;;;;AAKxE,eAAO,MAAM,SAAS,UAAW,MAAM,KAAG,OAAO,SAAS,CAMzD,CAAA"}

package/dist/Config/SecretURL.js

@@ -0,0 +1,49 @@
+import * as tsplus_module_1 from "effect/Config";
+import * as Either from "effect/Either";
+import * as internal from "./internal/configSecretURL.js";
+export const SecretURL = {};
+/**
+ * @tsplus static SecretURL.Ops isSecretURL
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isSecretURL = internal.isSecretURL;
+/**
+ * @tsplus static SecretURL.Ops make
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = internal.make;
+/**
+ * @tsplus static SecretURL.Ops fromChunk
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromChunk = internal.fromChunk;
+/**
+ * @tsplus static SecretURL.Ops fromString
+ * @since 1.0.0
+ * @category constructors
+ */
+const fromString_1 = internal.fromString;
+export const fromString = fromString_1;
+/**
+ * @tsplus getter SecretURL value
+ * @since 1.0.0
+ * @category getters
+ */
+export const value = internal.value;
+/**
+ * @tsplus fluent SecretURL unsafeWipe
+ * @since 1.0.0
+ * @category unsafe
+ */
+export const unsafeWipe = internal.unsafeWipe;
+/**
+ * @tsplus static effect/io/Config.Ops secretURL
+ */
+export const secretURL = (name) => {
+    const config = tsplus_module_1.primitive("a secret property", (text) => Either.right(fromString_1(text)));
+    return name === undefined ? config : tsplus_module_1.nested(config, name);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VjcmV0VVJMLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vX3NyYy9Db25maWcvU2VjcmV0VVJMLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFJQSxPQUFPLEtBQUssTUFBTSxNQUFNLGVBQWUsQ0FBQTtBQUd2QyxPQUFPLEtBQUssUUFBUSxNQUFNLCtCQUErQixDQUFBO0FBNkJ6RCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQWlCLEVBQUUsQ0FBQTtBQWV6Qzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFtQyxRQUFRLENBQUMsV0FBVyxDQUFBO0FBRS9FOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQXdDLFFBQVEsQ0FBQyxJQUFJLENBQUE7QUFFdEU7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBOEMsUUFBUSxDQUFDLFNBQVMsQ0FBQTtBQUV0Rjs7OztHQUlHO0FBQ0ksTUFBTSxlQUEwQyxRQUFRLENBQUMsVUFBVSxDQUFBO2FBQTdELFVBQVU7QUFFdkI7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBZ0MsUUFBUSxDQUFDLEtBQUssQ0FBQTtBQUVoRTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUE4QixRQUFRLENBQUMsVUFBVSxDQUFBO0FBRXhFOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLENBQUMsSUFBYSxFQUFxQixFQUFFO0lBQzVELE1BQU0sTUFBTSxHQUFHLDBCQUNiLG1CQUFtQixFQUNuQixDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxhQUFXLElBQUksQ0FBQyxDQUFDLENBQ3pDLENBQUE7SUFDRCxPQUFPLElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsdUJBQUEsTUFBTSxFQUFRLElBQUksQ0FBQyxDQUFBO0FBQzFELENBQUMsQ0FBQSJ9

package/dist/Config/internal/configSecretURL.d.ts

@@ -0,0 +1,24 @@
+import * as Chunk from "effect/Chunk";
+import * as EQ from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { SecretTypeId } from "effect/Secret";
+import type * as SecretURL from "../SecretURL.js";
+/** @internal */
+export declare const proto: {
+    [SecretTypeId]: symbol;
+    [Hash.symbol](this: SecretURL.SecretURL): number;
+    [EQ.symbol](this: SecretURL.SecretURL, that: unknown): boolean;
+};
+/** @internal */
+export declare const isSecretURL: (u: unknown) => u is SecretURL.SecretURL;
+/** @internal */
+export declare const make: (bytes: Array<number>) => SecretURL.SecretURL;
+/** @internal */
+export declare const fromChunk: (chunk: Chunk.Chunk<string>) => SecretURL.SecretURL;
+/** @internal */
+export declare const fromString: (text: string) => SecretURL.SecretURL;
+/** @internal */
+export declare const value: (self: SecretURL.SecretURL) => string;
+/** @internal */
+export declare const unsafeWipe: (self: SecretURL.SecretURL) => void;
+//# sourceMappingURL=configSecretURL.d.ts.map

package/dist/Config/internal/configSecretURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configSecretURL.d.ts","sourceRoot":"","sources":["../../../_src/Config/internal/configSecretURL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,SAAS,MAAM,iBAAiB,CAAA;AAKjD,gBAAgB;AAChB,eAAO,MAAM,KAAK;;wBAEI,mBAAmB,GAAG,MAAM;sBAM9B,mBAAmB,QAAQ,OAAO,GAAG,OAAO;CAG/D,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,WAAW,MAAO,OAAO,6BAErC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,MAAM,MAAM,CAAC,KAAG,mBAgC3C,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,WAAW,CAAC,MAAM,CAAC,KAAG,mBAEtD,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,UAAU,SAAU,MAAM,KAAG,mBAEzC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,KAAK,SAAU,mBAAmB,KAAG,MAEjD,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,UAAU,SAAU,mBAAmB,KAAG,IAItD,CAAA"}