envin 1.1.2 → 1.1.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { TPrefixFormat, TSharedFormat, TServerFormat, TClientFormat, TExtendsFormat, TSchema, FinalSchema, EnvOptions, DefineEnv } from './types.js';
+import { PrefixFormat, SharedFormat, ServerFormat, ClientFormat, ExtendsFormat, Schema, FinalSchema, EnvOptions, DefineEnv } from './types.js';
 
-declare function defineEnv<TPrefix extends TPrefixFormat, TShared extends TSharedFormat = NonNullable<unknown>, TServer extends TServerFormat = NonNullable<unknown>, TClient extends TClientFormat = NonNullable<unknown>, const TExtends extends TExtendsFormat = [], TFinalSchema extends TSchema = FinalSchema<TShared, TServer, TClient, TExtends>>(options: EnvOptions<TPrefix, TShared, TServer, TClient, TExtends, TFinalSchema>): DefineEnv<TFinalSchema>;
+declare function defineEnv<Prefix extends PrefixFormat, Shared extends SharedFormat = NonNullable<unknown>, Server extends ServerFormat = NonNullable<unknown>, Client extends ClientFormat = NonNullable<unknown>, const Extends extends ExtendsFormat = [], FinalSchemaType extends Schema = FinalSchema<Shared, Server, Client, Extends>>(options: EnvOptions<Prefix, Shared, Server, Client, Extends, FinalSchemaType>): DefineEnv<FinalSchemaType>;
 
 export { defineEnv };

package/dist/index.js

@@ -1 +1 @@
-function S(e,t){if(e instanceof Promise)throw new Error(t)}function m(e,t){let a={},u=[];for(let s in e){let o=e[s]?.["~standard"].validate(t[s]);if(S(o,`Validation must be synchronous, but ${s} returned a Promise.`),o?.issues){u.push(...o.issues.map(d=>({...d,path:[s,...d.path??[]]})));continue}a[s]=o?.value}return u.length?{issues:u}:{value:a}}var p=e=>["function","object"].includes(typeof e)&&!!e&&"~standard"in e&&typeof e["~standard"]=="object"&&!!e["~standard"]&&"validate"in e["~standard"],y=e=>{if(!(typeof e!="object"||e===null)){if("default"in e&&!["object","function"].includes(typeof e.default))return e.default;if("_def"in e&&typeof e._def=="object"&&e._def!==null&&"defaultValue"in e._def)return typeof e._def.defaultValue=="function"?e._def.defaultValue?.():e._def.defaultValue}},T=e=>Object.fromEntries(Object.entries(e).map(([t,a])=>[t,y(a)]));var F=e=>["__esModule","$$typeof"].includes(e),x=(e,t)=>({...e.shared&&e.shared,...e.server&&t&&e.server,...e.client&&e.client}),O=(e,t)=>({...e.extends?.reduce((u,s)=>({...u,...x(s,t)}),{}),...x(e,t)}),f=class extends Error{constructor(t){super(t),this.name="EnvError"}};function w(e){let t=e.envStrict??e.env??process.env;for(let[n,r]of Object.entries(t))r===""&&delete t[n];let a=e.isServer??(typeof window>"u"||"Deno"in window),u=e.onError??(n=>{throw console.error("\u274C Invalid environment variables:",n),new f("Invalid environment variables")}),s=e.onInvalidAccess??(n=>{throw new f(`\u274C Attempted to access a server-side environment variable on the client: ${n}`)}),o=!!e.skip,d=O(e,a),c=e.transform?.(d,a)??d,h=p(c)?y(c):T(c);if(o)return{...h,...t,_schema:d};let l=p(c)?c["~standard"].validate(t):m(d,t);if(S(l,"Validation must be synchronous!"),l.issues)return u(l.issues);let v=n=>{let r=[e,...e.extends??[]].map(i=>({keys:Object.keys(i.client??{}),prefix:i.clientPrefix})).some(i=>i.keys.includes(n)&&(!i.prefix||n.startsWith(i.prefix)));return![...Object.keys(e.shared??{}),...e.extends?.flatMap(i=>Object.keys(i.shared??{}))??[]].includes(n)&&!r},I=n=>a||!v(n);return new Proxy("value"in l?l.value:{},{get(n,r){if(typeof r=="string"&&!F(r))return r==="_schema"?d:I(r)?Reflect.get(n,r):s(r)}})}export{w as defineEnv};
+function S(e,t){if(e instanceof Promise)throw new Error(t)}function m(e,t){let a={},u=[];for(let s in e){let o=e[s]?.["~standard"].validate(t[s]);if(S(o,`Validation must be synchronous, but ${s} returned a Promise.`),o?.issues){u.push(...o.issues.map(d=>({...d,path:[s,...d.path??[]]})));continue}a[s]=o?.value}return u.length?{issues:u}:{value:a}}var p=e=>["function","object"].includes(typeof e)&&!!e&&"~standard"in e&&typeof e["~standard"]=="object"&&!!e["~standard"]&&"validate"in e["~standard"],y=e=>{if(!(typeof e!="object"||e===null)){if("default"in e&&!["object","function"].includes(typeof e.default))return e.default;if("_def"in e&&typeof e._def=="object"&&e._def!==null&&"defaultValue"in e._def)return typeof e._def.defaultValue=="function"?e._def.defaultValue?.():e._def.defaultValue}},x=e=>Object.fromEntries(Object.entries(e).map(([t,a])=>[t,y(a)]));var O=e=>["__esModule","$$typeof"].includes(e),h=(e,t)=>({...e.shared&&e.shared,...e.server&&t&&e.server,...e.client&&e.client}),k=(e,t)=>({...e.extends?.reduce((u,s)=>({...u,...h(s,t)}),{}),...h(e,t)}),f=class extends Error{constructor(t){super(t),this.name="EnvError"}};function P(e){let t=e.envStrict??e.env??process.env;for(let[n,r]of Object.entries(t))r===""&&delete t[n];let a=e.isServer??(typeof window>"u"||"Deno"in window),u=e.onError??(n=>{throw console.error("\u274C Invalid environment variables:",n),new f("Invalid environment variables")}),s=e.onInvalidAccess??(n=>{throw new f(`\u274C Attempted to access a server-side environment variable on the client: ${n}`)}),o=!!e.skip,d=k(e,a),c=e.transform?.(d,a)??d,v=p(c)?y(c):x(c);if(o)return{...v,...t,_schema:d};let l=p(c)?c["~standard"].validate(t):m(d,t);if(S(l,"Validation must be synchronous!"),l.issues)return u(l.issues);let I=n=>{let r=[e,...e.extends??[]].map(i=>({keys:Object.keys(i.client??{}),prefix:i.clientPrefix})).some(i=>i.keys.includes(n)&&(!i.prefix||n.startsWith(i.prefix)));return![...Object.keys(e.shared??{}),...e.extends?.flatMap(i=>Object.keys(i.shared??{}))??[]].includes(n)&&!r},F=n=>a||!I(n);return new Proxy("value"in l?l.value:{},{get(n,r){if(typeof r=="string"&&!O(r))return r==="_schema"?d:F(r)?Reflect.get(n,r):s(r)}})}export{P as defineEnv};

package/dist/presets/arktype.d.ts

@@ -155,7 +155,7 @@ declare const netlify: {
     readonly server: {
         readonly NETLIFY: arktype_internal_methods_base_ts.BaseType<string | undefined, {}>;
         readonly BUILD_ID: arktype_internal_methods_base_ts.BaseType<string | undefined, {}>;
-        readonly CONTEXT: arktype_internal_methods_base_ts.BaseType<"production" | "deploy-preview" | "branch-deploy" | "dev" | undefined, {}>;
+        readonly CONTEXT: arktype_internal_methods_base_ts.BaseType<"dev" | "production" | "deploy-preview" | "branch-deploy" | undefined, {}>;
         readonly REPOSITORY_URL: arktype_internal_methods_base_ts.BaseType<string | undefined, {}>;
         readonly BRANCH: arktype_internal_methods_base_ts.BaseType<string | undefined, {}>;
         readonly URL: arktype_internal_methods_base_ts.BaseType<string | undefined, {}>;

package/dist/presets/zod.d.ts

@@ -247,7 +247,7 @@ type ViteEnv = InferPresetOutput<typeof vite>;
 declare const wxt: {
     readonly id: "wxt";
     readonly server: {
-        readonly MANIFEST_VERSION: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodLiteral<2>, z.ZodLiteral<3>]>, 3 | 2, unknown>>;
+        readonly MANIFEST_VERSION: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodLiteral<2>, z.ZodLiteral<3>]>, 2 | 3, unknown>>;
         readonly BROWSER: z.ZodOptional<z.ZodEnum<["chrome", "firefox", "safari", "edge", "opera"]>>;
         readonly CHROME: z.ZodOptional<z.ZodBoolean>;
         readonly FIREFOX: z.ZodOptional<z.ZodBoolean>;

package/dist/types.d.ts

@@ -87,25 +87,25 @@ type UndefinedOptional<T> = Partial<Pick<T, PossiblyUndefinedKeys<T>>> & Omit<T,
 /** Converts a readonly type to a mutable type */
 type Mutable<T> = T extends Readonly<infer U> ? U : T;
 /** Extracts the combined schema from validation options */
-type ExtractCombinedSchema<T> = T extends ValidationOptions<TPrefixFormat, infer TShared, infer TServer, infer TClient> ? CombinedSchema<TShared, TServer, TClient> : T extends Readonly<ValidationOptions<TPrefixFormat, infer TShared, infer TServer, infer TClient>> ? CombinedSchema<TShared, TServer, TClient> : never;
+type ExtractCombinedSchema<T> = T extends ValidationOptions<PrefixFormat, infer Shared, infer Server, infer Client> ? CombinedSchema<Shared, Server, Client> : T extends Readonly<ValidationOptions<PrefixFormat, infer Shared, infer Server, infer Client>> ? CombinedSchema<Shared, Server, Client> : never;
 /** Reduces an array of schemas to a single schema */
-type Reduce<TArr extends readonly unknown[] | unknown[], TAcc extends StandardSchemaDictionary<object, object> = StandardSchemaDictionary<object, object>> = TArr extends readonly [] | [] ? TAcc : TArr extends readonly [infer Head, ...infer Tail] | [infer Head, ...infer Tail] ? Tail extends readonly unknown[] | unknown[] ? Mutable<Reduce<Tail, CombinedSchema<TAcc, ExtractCombinedSchema<Head>>>> : never : never;
-type InferPresetOutput<T extends TExtendsFormat[number]> = StandardSchemaDictionary.InferOutput<ExtractCombinedSchema<T>>;
-type CombinedSchema<TShared extends TSharedFormat = TSharedFormat, TServer extends TServerFormat = TServerFormat, TClient extends TClientFormat = TClientFormat> = Merge<TShared, Merge<TServer, TClient>>;
-type TPrefixFormat = string | undefined;
-type TSharedFormat = StandardSchemaDictionary<object, object>;
-type TServerFormat = StandardSchemaDictionary<object, object>;
-type TClientFormat = StandardSchemaDictionary<object, object>;
-type TExtendsFormat = (TPreset | Readonly<TPreset>)[] | ReadonlyArray<TPreset>;
-type TPreset<TPrefix extends TPrefixFormat = TPrefixFormat, TShared extends TSharedFormat = TSharedFormat, TServer extends TServerFormat = TServerFormat, TClient extends TClientFormat = TClientFormat> = ValidationOptions<TPrefix, TShared, TServer, TClient> & {
+type Reduce<Arr extends readonly unknown[] | unknown[], Acc extends StandardSchemaDictionary<object, object> = StandardSchemaDictionary<object, object>> = Arr extends readonly [] | [] ? Acc : Arr extends readonly [infer Head, ...infer Tail] | [infer Head, ...infer Tail] ? Tail extends readonly unknown[] | unknown[] ? Mutable<Reduce<Tail, CombinedSchema<Acc, ExtractCombinedSchema<Head>>>> : never : never;
+type InferPresetOutput<T extends ExtendsFormat[number]> = StandardSchemaDictionary.InferOutput<ExtractCombinedSchema<T>>;
+type CombinedSchema<Shared extends SharedFormat = SharedFormat, Server extends ServerFormat = ServerFormat, Client extends ClientFormat = ClientFormat> = Merge<Shared, Merge<Server, Client>>;
+type PrefixFormat = string | undefined;
+type SharedFormat = StandardSchemaDictionary<object, object>;
+type ServerFormat = StandardSchemaDictionary<object, object>;
+type ClientFormat = StandardSchemaDictionary<object, object>;
+type ExtendsFormat = (Preset | Readonly<Preset>)[] | ReadonlyArray<Preset>;
+type Preset<Prefix extends PrefixFormat = PrefixFormat, Shared extends SharedFormat = SharedFormat, Server extends ServerFormat = ServerFormat, Client extends ClientFormat = ClientFormat> = ValidationOptions<Prefix, Shared, Server, Client> & {
     id?: string;
 };
-type TSchema = StandardSchemaV1<object, object>;
-interface BaseOptions<TExtends extends TExtendsFormat> {
+type Schema = StandardSchemaV1<object, object>;
+interface BaseOptions<Extends extends ExtendsFormat> {
     /**
      * Array of preset configurations to extend from.
      */
-    extends?: TExtends;
+    extends?: Extends;
     /**
      * Whether to skip validation of environment variables.
      * @default false
@@ -127,7 +127,7 @@ interface BaseOptions<TExtends extends TExtendsFormat> {
      */
     onInvalidAccess?: (variable: string) => never;
 }
-interface LooseOptions<TExtends extends TExtendsFormat> extends BaseOptions<TExtends> {
+interface LooseOptions<Extends extends ExtendsFormat> extends BaseOptions<Extends> {
     /**
      * Must be undefined when using loose options. Use `env` instead.
      */
@@ -139,65 +139,65 @@ interface LooseOptions<TExtends extends TExtendsFormat> extends BaseOptions<TExt
      */
     env?: Record<string, string | boolean | number | undefined>;
 }
-interface StrictOptions<TPrefix extends TPrefixFormat, TServer extends TServerFormat, TClient extends TClientFormat, TShared extends TSharedFormat, TExtends extends TExtendsFormat> extends BaseOptions<TExtends> {
+interface StrictOptions<Prefix extends PrefixFormat, Server extends ServerFormat, Client extends ClientFormat, Shared extends SharedFormat, Extends extends ExtendsFormat> extends BaseOptions<Extends> {
     /**
      * Runtime Environment variables to use for validation - `process.env`, `import.meta.env` or similar.
      * Enforces all environment variables to be set. Required in for example Next.js Edge and Client runtimes.
      */
     envStrict?: Record<{
-        [TKey in keyof TClient]: TPrefix extends undefined ? never : TKey extends `${TPrefix}${string}` ? TKey : never;
-    }[keyof TClient] | {
-        [TKey in keyof TServer]: TPrefix extends undefined ? TKey : TKey extends `${TPrefix}${string}` ? never : TKey;
-    }[keyof TServer] | {
-        [TKey in keyof TShared]: TKey extends string ? TKey : never;
-    }[keyof TShared], string | boolean | number | undefined>;
+        [Key in keyof Client]: Prefix extends undefined ? never : Key extends `${Prefix}${string}` ? Key : never;
+    }[keyof Client] | {
+        [Key in keyof Server]: Prefix extends undefined ? Key : Key extends `${Prefix}${string}` ? never : Key;
+    }[keyof Server] | {
+        [Key in keyof Shared]: Key extends string ? Key : never;
+    }[keyof Shared], string | boolean | number | undefined>;
     /**
      * Must be undefined when using strict options. Use `envStrict` instead.
      */
     env?: never;
 }
-interface SharedOptions<TShared extends TSharedFormat> {
+interface SharedOptions<Shared extends SharedFormat> {
     /**
      * Specify your shared environment variables schema here. These variables are available on both client and server.
      */
-    shared?: TShared;
+    shared?: Shared;
 }
-interface ClientOptions<TPrefix extends TPrefixFormat, TClient extends TClientFormat> {
+interface ClientOptions<Prefix extends PrefixFormat, Client extends ClientFormat> {
     /**
      * The prefix that client-side variables must have. This is enforced both at
      * a type-level and at runtime.
      */
-    clientPrefix?: TPrefix;
+    clientPrefix?: Prefix;
     /**
      * Specify your client-side environment variables schema here. This way you can ensure the app isn't
      * built with invalid env vars.
      */
     client?: Partial<{
-        [TKey in keyof TClient]: TKey extends `${TPrefix}${string}` ? TClient[TKey] : ErrorMessage<`${TKey extends string ? TKey : never} is not prefixed with ${TPrefix}.`>;
+        [Key in keyof Client]: Key extends `${Prefix}${string}` ? Client[Key] : ErrorMessage<`${Key extends string ? Key : never} is not prefixed with ${Prefix}.`>;
     }>;
 }
-interface ServerOptions<TPrefix extends TPrefixFormat, TServer extends TServerFormat> {
+interface ServerOptions<Prefix extends PrefixFormat, Server extends ServerFormat> {
     /**
      * Specify your server-side environment variables schema here. This way you can ensure the app isn't
      * built with invalid env vars.
      */
     server: Partial<{
-        [TKey in keyof TServer]: TPrefix extends undefined ? TServer[TKey] : TPrefix extends "" ? TServer[TKey] : TKey extends `${TPrefix}${string}` ? ErrorMessage<`${TKey extends `${TPrefix}${string}` ? TKey : never} should not prefixed with ${TPrefix}.`> : TServer[TKey];
+        [Key in keyof Server]: Prefix extends undefined ? Server[Key] : Prefix extends "" ? Server[Key] : Key extends `${Prefix}${string}` ? ErrorMessage<`${Key extends `${Prefix}${string}` ? Key : never} should not prefixed with ${Prefix}.`> : Server[Key];
     }>;
 }
-type ValidationOptions<TPrefix extends TPrefixFormat = TPrefixFormat, TShared extends TSharedFormat = TSharedFormat, TServer extends TServerFormat = TServerFormat, TClient extends TClientFormat = TClientFormat> = ((ClientOptions<TPrefix, TClient> & ServerOptions<TPrefix, TServer>) | (ServerOptions<TPrefix, TServer> & Impossible<ClientOptions<never, never>>) | (ClientOptions<TPrefix, TClient> & Impossible<ServerOptions<never, never>>)) & SharedOptions<TShared>;
-interface TransformSchemaOptions<TShared extends TSharedFormat, TServer extends TServerFormat, TClient extends TClientFormat, TExtends extends TExtendsFormat, TFinalSchema extends TSchema> {
+type ValidationOptions<Prefix extends PrefixFormat = PrefixFormat, Shared extends SharedFormat = SharedFormat, Server extends ServerFormat = ServerFormat, Client extends ClientFormat = ClientFormat> = ((ClientOptions<Prefix, Client> & ServerOptions<Prefix, Server>) | (ServerOptions<Prefix, Server> & Impossible<ClientOptions<never, never>>) | (ClientOptions<Prefix, Client> & Impossible<ServerOptions<never, never>>)) & SharedOptions<Shared>;
+interface TransformSchemaOptions<Shared extends SharedFormat, Server extends ServerFormat, Client extends ClientFormat, Extends extends ExtendsFormat, FinalSchema extends Schema> {
     /**
      * A custom function to combine the schemas.
      * Can be used to add further refinement or transformation.
      */
-    transform?: (shape: Simplify<FullSchemaShape<TShared, TServer, TClient, TExtends>>, isServer: boolean) => TFinalSchema;
+    transform?: (shape: Simplify<FullSchemaShape<Shared, Server, Client, Extends>>, isServer: boolean) => FinalSchema;
 }
-type EnvOptions<TPrefix extends TPrefixFormat = TPrefixFormat, TShared extends TSharedFormat = TSharedFormat, TServer extends TServerFormat = TServerFormat, TClient extends TClientFormat = TClientFormat, TExtends extends TExtendsFormat = TExtendsFormat, TFinalSchema extends TSchema = TSchema> = (LooseOptions<TExtends> | StrictOptions<TPrefix, TServer, TClient, TShared, TExtends>) & ValidationOptions<TPrefix, TShared, TServer, TClient> & TransformSchemaOptions<TShared, TServer, TClient, TExtends, TFinalSchema>;
-type FullSchemaShape<TShared extends TSharedFormat, TServer extends TServerFormat, TClient extends TClientFormat, TExtends extends TExtendsFormat> = CombinedSchema<Reduce<TExtends>, CombinedSchema<TShared, TServer, TClient>>;
-type FinalSchema<TShared extends TSharedFormat, TServer extends TServerFormat, TClient extends TClientFormat, TExtends extends TExtendsFormat> = StandardSchemaV1<object, UndefinedOptional<StandardSchemaDictionary.InferOutput<FullSchemaShape<TShared, TServer, TClient, TExtends>>>>;
-type DefineEnv<TFinalSchema extends TSchema = TSchema> = Simplify<Readonly<StandardSchemaV1.InferOutput<TFinalSchema> & {
-    _schema: TFinalSchema;
+type EnvOptions<Prefix extends PrefixFormat = PrefixFormat, Shared extends SharedFormat = SharedFormat, Server extends ServerFormat = ServerFormat, Client extends ClientFormat = ClientFormat, Extends extends ExtendsFormat = ExtendsFormat, FinalSchema extends Schema = Schema> = (LooseOptions<Extends> | StrictOptions<Prefix, Server, Client, Shared, Extends>) & ValidationOptions<Prefix, Shared, Server, Client> & TransformSchemaOptions<Shared, Server, Client, Extends, FinalSchema>;
+type FullSchemaShape<Shared extends SharedFormat, Server extends ServerFormat, Client extends ClientFormat, Extends extends ExtendsFormat> = CombinedSchema<Reduce<Extends>, CombinedSchema<Shared, Server, Client>>;
+type FinalSchema<Shared extends SharedFormat, Server extends ServerFormat, Client extends ClientFormat, Extends extends ExtendsFormat> = StandardSchemaV1<object, UndefinedOptional<StandardSchemaDictionary.InferOutput<FullSchemaShape<Shared, Server, Client, Extends>>>>;
+type DefineEnv<FinalSchema extends Schema = Schema> = Simplify<Readonly<StandardSchemaV1.InferOutput<FinalSchema> & {
+    _schema: FinalSchema;
 }>>;
 
-export type { BaseOptions, ClientOptions, CombinedSchema, DefineEnv, EnvOptions, ErrorMessage, FinalSchema, FullSchemaShape, InferPresetOutput, LooseOptions, ServerOptions, SharedOptions, Simplify, StrictOptions, TClientFormat, TExtendsFormat, TPrefixFormat, TPreset, TSchema, TServerFormat, TSharedFormat, TransformSchemaOptions, ValidationOptions };
+export type { BaseOptions, ClientFormat, ClientOptions, CombinedSchema, DefineEnv, EnvOptions, ErrorMessage, ExtendsFormat, FinalSchema, FullSchemaShape, InferPresetOutput, LooseOptions, PrefixFormat, Preset, Schema, ServerFormat, ServerOptions, SharedFormat, SharedOptions, Simplify, StrictOptions, TransformSchemaOptions, ValidationOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envin",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Type-safe env validation with live previews",
   "keywords": [
     "turbostarter",