@magidoc/plugin-starter-variables 1.1.1 → 2.0.0

package/build/env/envFileContent.d.ts

@@ -0,0 +1,6 @@
+import type { Variable } from '../variables/variable';
+export declare function toVariablesFile(options: Record<string, unknown>, supportedVariables: ReadonlyArray<Variable<unknown>>): string;
+export declare class UnsupportedVariablesError extends Error {
+    unsupportedVariables: string[];
+    constructor(message: string, unsupportedVariables: string[]);
+}

package/build/env/envFileContent.js

@@ -0,0 +1,45 @@
+import _ from 'lodash';
+import magidoc from '../variables/magidoc.js';
+
+function toVariablesFile(options, supportedVariables) {
+    return asVariablesString(buildEnv(options, supportedVariables));
+}
+function asVariablesString(env) {
+    return JSON.stringify(env);
+}
+function buildEnv(options, supportedVariables) {
+    let newRecord = {};
+    const unsupportedVariables = [];
+    _.forEach(options, (value, key) => {
+        const variable = supportedVariables.find((option) => option.name === key);
+        if (!variable) {
+            unsupportedVariables.push(key);
+            return;
+        }
+        newRecord = {
+            ...newRecord,
+            ...variable.asEnv(value),
+        };
+    });
+    if (unsupportedVariables.length > 0) {
+        throw new UnsupportedVariablesError(`Options [${unsupportedVariables.toString()}] are not supported... Supported option names are [${supportedVariables
+            .map((value) => value.name)
+            .join(', ')}]`, unsupportedVariables);
+    }
+    insertDefaultVariables(newRecord);
+    return newRecord;
+}
+function insertDefaultVariables(newRecord) {
+    newRecord[magidoc.MAGIDOC_GENERATE.key] = 'true';
+}
+class UnsupportedVariablesError extends Error {
+    unsupportedVariables;
+    constructor(message, unsupportedVariables) {
+        super(message);
+        this.unsupportedVariables = unsupportedVariables;
+        this.name = 'UnsupportedVariableError';
+    }
+}
+
+export { UnsupportedVariablesError, toVariablesFile };
+//# sourceMappingURL=envFileContent.js.map

package/build/env/envFileContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envFileContent.js","sources":["../../../src/env/envFileContent.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIgB,SAAA,eAAe,CAC7B,OAAgC,EAChC,kBAAoD,EAAA;IAEpD,OAAO,iBAAiB,CAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAA;AACjE,CAAC;AAED,SAAS,iBAAiB,CAAC,GAA2B,EAAA;AACpD,IAAA,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;AAC5B,CAAC;AAED,SAAS,QAAQ,CACf,OAAgC,EAChC,kBAAoD,EAAA;IAEpD,IAAI,SAAS,GAA2B,EAAE,CAAA;IAC1C,MAAM,oBAAoB,GAAa,EAAE,CAAA;IACzC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAI;AAChC,QAAA,MAAM,QAAQ,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,KAAK,GAAG,CAAC,CAAA;QACzE,IAAI,CAAC,QAAQ,EAAE;AACb,YAAA,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC9B,OAAM;AACP,SAAA;AAED,QAAA,SAAS,GAAG;AACV,YAAA,GAAG,SAAS;AACZ,YAAA,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;SACzB,CAAA;AACH,KAAC,CAAC,CAAA;AAEF,IAAA,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE;QACnC,MAAM,IAAI,yBAAyB,CACjC,CAAA,SAAA,EAAY,oBAAoB,CAAC,QAAQ,EAAE,CAAA,mDAAA,EAAsD,kBAAkB;aAChH,GAAG,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC;AAC1B,aAAA,IAAI,CAAC,IAAI,CAAC,GAAG,EAChB,oBAAoB,CACrB,CAAA;AACF,KAAA;IAED,sBAAsB,CAAC,SAAS,CAAC,CAAA;AACjC,IAAA,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAS,sBAAsB,CAAC,SAAiC,EAAA;IAC/D,SAAS,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,MAAM,CAAA;AAClD,CAAC;AAEK,MAAO,yBAA0B,SAAQ,KAAK,CAAA;AAC3C,IAAA,oBAAoB,CAAU;IAErC,WAAY,CAAA,OAAe,EAAE,oBAA8B,EAAA;QACzD,KAAK,CAAC,OAAO,CAAC,CAAA;AACd,QAAA,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAA;AAChD,QAAA,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAA;KACvC;AACF;;;;"}

package/build/index.d.ts

@@ -1,7 +1,9 @@
 import templates from './variables/templates';
 import magidoc from './variables/magidoc';
-import type { Variable, ViteVariable } from './variables/variable';
+import { toVariablesFile, UnsupportedVariablesError } from './env/envFileContent';
+import type { Variable } from './variables/variable';
 import type { Page } from './variables/templates';
 export { templates };
 export { magidoc };
-export type { Variable, ViteVariable, Page };
+export type { Variable, Page };
+export { toVariablesFile, UnsupportedVariablesError };

package/build/index.js

@@ -1,3 +1,4 @@
 export { default as templates } from './variables/templates.js';
 export { default as magidoc } from './variables/magidoc.js';
+export { UnsupportedVariablesError, toVariablesFile } from './env/envFileContent.js';
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/build/variables/variable.d.ts

@@ -1,15 +1,14 @@
 import type { ZodType, ZodTypeDef } from 'zod';
-/**
- * Copy of the ViteJS import meta interface
- */
 interface MetaEnv {
     [key: string]: unknown;
 }
 export declare type Variable<T> = {
     name: string;
+    key: string;
     asEnv: (value: T) => Record<string, string>;
+    get: (env: MetaEnv) => T | null;
+    getOrDefault: (env: MetaEnv, def: T) => T;
     zod: ZodVariable<T>;
-    vite: ViteVariable<T>;
 };
 export declare type ZodTypeProvider<T> = (zod: typeof import('zod')) => ZodType<T | undefined, ZodTypeDef, T | undefined>;
 export declare type ZodVariable<T> = {
@@ -20,10 +19,5 @@ export declare type Converter<T> = {
     asString: (value: T) => string;
     type: ZodTypeProvider<T>;
 };
-export declare type ViteVariable<T> = {
-    key: string;
-    get: (env: MetaEnv) => T | null;
-    getOrDefault: (env: MetaEnv, def: T) => T;
-};
 export declare function createVariable<T>(key: string, converter: Converter<T>): Variable<T>;
 export {};

package/build/variables/variable.js

@@ -1,17 +1,14 @@
 function createVariable(key, converter) {
-    const viteKey = `VITE_${key.toUpperCase()}`;
-    const viteGet = (env) => converter.convert(env[viteKey]);
+    const get = (env) => converter.convert(env[key]);
     return {
         name: toCamelCase(key),
-        asEnv: (value) => ({ [viteKey]: converter.asString(value) }),
+        key: key,
+        asEnv: (value) => ({ [key]: converter.asString(value) }),
         zod: {
             type: converter.type,
         },
-        vite: {
-            key: viteKey,
-            get: viteGet,
-            getOrDefault: (env, def) => viteGet(env) ?? def,
-        },
+        get: get,
+        getOrDefault: (env, def) => get(env) ?? def,
     };
 }
 function toCamelCase(key) {

package/build/variables/variable.js.map

@@ -1 +1 @@
-{"version":3,"file":"variable.js","sources":["../../../src/variables/variable.ts"],"sourcesContent":[null],"names":[],"mappings":"AAoCgB,SAAA,cAAc,CAC5B,GAAW,EACX,SAAuB,EAAA;IAEvB,MAAM,OAAO,GAAG,CAAQ,KAAA,EAAA,GAAG,CAAC,WAAW,EAAE,EAAE,CAAA;AAC3C,IAAA,MAAM,OAAO,GAAG,CAAC,GAAY,KAAK,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAEjE,OAAO;AACL,QAAA,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC;AACtB,QAAA,KAAK,EAAE,CAAC,KAAQ,MAAM,EAAE,CAAC,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AAC/D,QAAA,GAAG,EAAE;YACH,IAAI,EAAE,SAAS,CAAC,IAAI;AACrB,SAAA;AACD,QAAA,IAAI,EAAE;AACJ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,GAAG,EAAE,OAAO;AACZ,YAAA,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG;AAChD,SAAA;KACF,CAAA;AACH,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAA;AAC9B,IAAA,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,EAAE,KAAI;AACvD,QAAA,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3D,KAAC,CAAC,CAAA;AACJ;;;;"}
+{"version":3,"file":"variable.js","sources":["../../../src/variables/variable.ts"],"sourcesContent":[null],"names":[],"mappings":"AA6BgB,SAAA,cAAc,CAC5B,GAAW,EACX,SAAuB,EAAA;AAEvB,IAAA,MAAM,GAAG,GAAG,CAAC,GAAY,KAAK,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;IAEzD,OAAO;AACL,QAAA,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC;AACtB,QAAA,GAAG,EAAE,GAAG;AACR,QAAA,KAAK,EAAE,CAAC,KAAQ,MAAM,EAAE,CAAC,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AAC3D,QAAA,GAAG,EAAE;YACH,IAAI,EAAE,SAAS,CAAC,IAAI;AACrB,SAAA;AACD,QAAA,GAAG,EAAE,GAAG;AACR,QAAA,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG;KAC5C,CAAA;AACH,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAA;AAC9B,IAAA,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,EAAE,KAAI;AACvD,QAAA,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC3D,KAAC,CAAC,CAAA;AACJ;;;;"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@magidoc/plugin-starter-variables",
   "description": "A shared library that contains common Magidoc starter environment variables keys.",
   "private": false,
-  "version": "1.1.1",
+  "version": "2.0.0",
   "type": "module",
   "license": "MIT",
   "main": "./build/index.js",
@@ -19,12 +19,15 @@
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^8.3.2",
-    "@types/jest": "^27.5.1",
+    "@types/jest": "^28.1.1",
+    "@types/lodash": "^4.14.182",
+    "@types/node": "^17.0.40",
     "jest": "^28.1.0",
-    "rollup": "^2.75.3",
-    "ts-jest": "^28.0.3",
+    "lodash": "^4.17.21",
+    "rollup": "^2.75.5",
+    "ts-jest": "^28.0.4",
     "tslib": "^2.4.0",
-    "typescript": "^4.7.2"
+    "typescript": "^4.7.3"
   },
   "optionalDependencies": {
     "zod": "^3.17.3"

package/rollup.config.cjs

@@ -4,7 +4,7 @@ const typescript = require('@rollup/plugin-typescript')
 module.exports = defineConfig({
   input: ['src/index.ts'],
   plugins: [typescript()],
-  external: ['zod'],
+  external: ['zod', 'lodash'],
   output: {
     dir: 'build',
     format: 'esm',

package/src/env/envFileContent.ts

@@ -0,0 +1,60 @@
+import _ from 'lodash'
+import magidoc from '../variables/magidoc'
+import type { Variable } from '../variables/variable'
+
+export function toVariablesFile(
+  options: Record<string, unknown>,
+  supportedVariables: ReadonlyArray<Variable<unknown>>,
+): string {
+  return asVariablesString(buildEnv(options, supportedVariables))
+}
+
+function asVariablesString(env: Record<string, string>) {
+  return JSON.stringify(env)
+}
+
+function buildEnv(
+  options: Record<string, unknown>,
+  supportedVariables: ReadonlyArray<Variable<unknown>>,
+): Record<string, string> {
+  let newRecord: Record<string, string> = {}
+  const unsupportedVariables: string[] = []
+  _.forEach(options, (value, key) => {
+    const variable = supportedVariables.find((option) => option.name === key)
+    if (!variable) {
+      unsupportedVariables.push(key)
+      return
+    }
+
+    newRecord = {
+      ...newRecord,
+      ...variable.asEnv(value),
+    }
+  })
+
+  if (unsupportedVariables.length > 0) {
+    throw new UnsupportedVariablesError(
+      `Options [${unsupportedVariables.toString()}] are not supported... Supported option names are [${supportedVariables
+        .map((value) => value.name)
+        .join(', ')}]`,
+      unsupportedVariables,
+    )
+  }
+
+  insertDefaultVariables(newRecord)
+  return newRecord
+}
+
+function insertDefaultVariables(newRecord: Record<string, string>) {
+  newRecord[magidoc.MAGIDOC_GENERATE.key] = 'true'
+}
+
+export class UnsupportedVariablesError extends Error {
+  public unsupportedVariables: string[]
+
+  constructor(message: string, unsupportedVariables: string[]) {
+    super(message)
+    this.unsupportedVariables = unsupportedVariables
+    this.name = 'UnsupportedVariableError'
+  }
+}

package/src/index.ts

@@ -1,8 +1,13 @@
 import templates from './variables/templates'
 import magidoc from './variables/magidoc'
-import type { Variable, ViteVariable } from './variables/variable'
+import {
+  toVariablesFile,
+  UnsupportedVariablesError,
+} from './env/envFileContent'
+import type { Variable } from './variables/variable'
 import type { Page } from './variables/templates'
 
 export { templates }
 export { magidoc }
-export type { Variable, ViteVariable, Page }
+export type { Variable, Page }
+export { toVariablesFile, UnsupportedVariablesError }

package/src/variables/variable.ts

@@ -1,17 +1,16 @@
 import type { ZodType, ZodTypeDef } from 'zod'
 
-/**
- * Copy of the ViteJS import meta interface
- */
 interface MetaEnv {
   [key: string]: unknown
 }
 
 export type Variable<T> = {
   name: string
+  key: string
   asEnv: (value: T) => Record<string, string>
+  get: (env: MetaEnv) => T | null
+  getOrDefault: (env: MetaEnv, def: T) => T
   zod: ZodVariable<T>
-  vite: ViteVariable<T>
 }
 
 export type ZodTypeProvider<T> = (
@@ -28,30 +27,21 @@ export type Converter<T> = {
   type: ZodTypeProvider<T>
 }
 
-export type ViteVariable<T> = {
-  key: string
-  get: (env: MetaEnv) => T | null
-  getOrDefault: (env: MetaEnv, def: T) => T
-}
-
 export function createVariable<T>(
   key: string,
   converter: Converter<T>,
 ): Variable<T> {
-  const viteKey = `VITE_${key.toUpperCase()}`
-  const viteGet = (env: MetaEnv) => converter.convert(env[viteKey])
+  const get = (env: MetaEnv) => converter.convert(env[key])
 
   return {
     name: toCamelCase(key),
-    asEnv: (value: T) => ({ [viteKey]: converter.asString(value) }),
+    key: key,
+    asEnv: (value: T) => ({ [key]: converter.asString(value) }),
     zod: {
       type: converter.type,
     },
-    vite: {
-      key: viteKey,
-      get: viteGet,
-      getOrDefault: (env, def) => viteGet(env) ?? def,
-    },
+    get: get,
+    getOrDefault: (env, def) => get(env) ?? def,
   }
 }
 

package/tests/env/envFileContent.spec.ts

@@ -0,0 +1,54 @@
+import { templates, Variable, magidoc, toVariablesFile } from '../../src'
+import { UnsupportedVariablesError } from '../../src/env/envFileContent'
+
+describe('creating a variables file ', () => {
+  const initialObject = {
+    appTitle: 'My App',
+    pages: [
+      {
+        title: 'My-page-title',
+        content:
+          'A raw markdown string containing stuff like "double quotes", `code`, and **bold**.',
+      },
+      {
+        title: 'My-page-title-2',
+        content: [
+          {
+            title:
+              "This is another page, but this one contains 'single quotes', ```much more code```,\n new lines \n\n # And a new header apparently",
+          },
+        ],
+      },
+    ],
+  }
+
+  describe('all provided options are supported', () => {
+    const result = toVariablesFile(initialObject, [
+      templates.APP_TITLE as Variable<unknown>,
+      templates.PAGES as Variable<unknown>,
+    ])
+
+    it('is possible to convert it back to the original object using variables', () => {
+      const parsed = JSON.parse(result) as Record<string, string>
+
+      expect(magidoc.MAGIDOC_GENERATE.get(parsed)).toBe(true)
+      expect(templates.APP_TITLE.get(parsed)).toBe(initialObject.appTitle)
+      expect(templates.PAGES.get(parsed)).toEqual(initialObject.pages)
+    })
+  })
+
+  describe('some of the options are unsupported', () => {
+    it('raises an error', () => {
+      expect.assertions(2)
+
+      try {
+        toVariablesFile(initialObject, [])
+      } catch (error) {
+        expect(error).toBeInstanceOf(UnsupportedVariablesError)
+        expect(
+          (error as UnsupportedVariablesError).unsupportedVariables,
+        ).toEqual(['appTitle', 'pages'])
+      }
+    })
+  })
+})

package/tests/index.spec.ts

@@ -6,7 +6,12 @@ import type { Page } from '../src/index'
 
 describe('variables', () => {
   it('contains the right number of export keys', () => {
-    expect(Object.keys(variables)).toEqual(['templates', 'magidoc'])
+    expect(Object.keys(variables)).toEqual([
+      'templates',
+      'magidoc',
+      'toVariablesFile',
+      'UnsupportedVariablesError',
+    ])
   })
 
   describe('template variables', () => {
@@ -25,7 +30,7 @@ describe('variables', () => {
     test('app title', () => {
       testStringVariable(
         variables.templates.APP_TITLE,
-        'VITE_APP_TITLE',
+        'APP_TITLE',
         z.string().optional(),
       )
     })
@@ -33,7 +38,7 @@ describe('variables', () => {
     test('app logo', () => {
       testStringVariable(
         variables.templates.APP_LOGO,
-        'VITE_APP_LOGO',
+        'APP_LOGO',
         z.string().optional(),
       )
     })
@@ -41,7 +46,7 @@ describe('variables', () => {
     test('app favicon', () => {
       testStringVariable(
         variables.templates.APP_FAVICON,
-        'VITE_APP_FAVICON',
+        'APP_FAVICON',
         z.string().optional(),
       )
     })
@@ -49,7 +54,7 @@ describe('variables', () => {
     test('site root', () => {
       testStringVariable(
         variables.templates.SITE_ROOT,
-        'VITE_SITE_ROOT',
+        'SITE_ROOT',
         z.string().optional(),
       )
     })
@@ -57,7 +62,7 @@ describe('variables', () => {
     test('site meta', () => {
       testRecordVariable(
         variables.templates.SITE_META,
-        'VITE_SITE_META',
+        'SITE_META',
         z.record(z.string().optional()).optional(),
       )
     })
@@ -65,7 +70,7 @@ describe('variables', () => {
     test('query generation factories', () => {
       testRecordVariable(
         variables.templates.QUERY_GENERATION_FACTORIES,
-        'VITE_QUERY_GENERATION_FACTORIES',
+        'QUERY_GENERATION_FACTORIES',
         z
           .record(
             z
@@ -92,7 +97,7 @@ describe('variables', () => {
 
       testArrayVariable(
         variables.templates.PAGES,
-        'VITE_PAGES',
+        'PAGES',
         z.array(pagesType).optional(),
       )
     })
@@ -106,7 +111,7 @@ describe('variables', () => {
     test('magidoc generate', () => {
       testBooleanVariable(
         variables.magidoc.MAGIDOC_GENERATE,
-        'VITE_MAGIDOC_GENERATE',
+        'MAGIDOC_GENERATE',
         z.boolean().optional(),
       )
     })
@@ -115,24 +120,20 @@ describe('variables', () => {
 
 function testStringVariable(
   target: Variable<string>,
-  viteKey: string,
+  key: string,
   expectedZod: ZodType<any>,
 ) {
-  expect(target.vite.key).toEqual(viteKey)
+  expect(target.key).toEqual(key)
 
-  expect(target.vite.get({ [viteKey]: 'Potato' })).toBe('Potato')
-  expect(target.vite.get({ [viteKey]: false })).toBe('false')
-  expect(target.vite.get({})).toBeNull()
+  expect(target.get({ [key]: 'Potato' })).toBe('Potato')
+  expect(target.get({ [key]: false })).toBe('false')
+  expect(target.get({})).toBeNull()
 
-  expect(target.vite.getOrDefault({ [viteKey]: 'Potato' }, 'Default')).toBe(
-    'Potato',
-  )
-  expect(target.vite.getOrDefault({ [viteKey]: false }, 'Default')).toBe(
-    'false',
-  )
-  expect(target.vite.getOrDefault({}, 'Default')).toBe('Default')
+  expect(target.getOrDefault({ [key]: 'Potato' }, 'Default')).toBe('Potato')
+  expect(target.getOrDefault({ [key]: false }, 'Default')).toBe('false')
+  expect(target.getOrDefault({}, 'Default')).toBe('Default')
 
-  expect(target.asEnv('Potato')).toEqual({ [viteKey]: 'Potato' })
+  expect(target.asEnv('Potato')).toEqual({ [key]: 'Potato' })
 
   ensureZodTypeEqual(target, expectedZod)
 }
@@ -142,27 +143,27 @@ function testBooleanVariable(
   viteKey: string,
   expectedZod: ZodType<any>,
 ) {
-  expect(target.vite.key).toEqual(viteKey)
+  expect(target.key).toEqual(viteKey)
 
-  expect(target.vite.get({ [viteKey]: true })).toBe(true)
-  expect(target.vite.get({ [viteKey]: 'true' })).toBe(true)
-  expect(target.vite.get({ [viteKey]: 't' })).toBe(true)
-  expect(target.vite.get({ [viteKey]: '1' })).toBe(true)
-  expect(target.vite.get({ [viteKey]: 12 })).toBe(true)
+  expect(target.get({ [viteKey]: true })).toBe(true)
+  expect(target.get({ [viteKey]: 'true' })).toBe(true)
+  expect(target.get({ [viteKey]: 't' })).toBe(true)
+  expect(target.get({ [viteKey]: '1' })).toBe(true)
+  expect(target.get({ [viteKey]: 12 })).toBe(true)
 
-  expect(target.vite.get({ [viteKey]: false })).toBe(false)
-  expect(target.vite.get({ [viteKey]: 'false' })).toBe(false)
-  expect(target.vite.get({ [viteKey]: 'wow' })).toBe(false)
-  expect(target.vite.get({ [viteKey]: 0 })).toBe(false)
+  expect(target.get({ [viteKey]: false })).toBe(false)
+  expect(target.get({ [viteKey]: 'false' })).toBe(false)
+  expect(target.get({ [viteKey]: 'wow' })).toBe(false)
+  expect(target.get({ [viteKey]: 0 })).toBe(false)
 
-  expect(target.vite.get({ [viteKey]: {} })).toBeNull()
-  expect(target.vite.get({ [viteKey]: null })).toBeNull()
-  expect(target.vite.get({ [viteKey]: undefined })).toBeNull()
-  expect(target.vite.get({})).toBeNull()
+  expect(target.get({ [viteKey]: {} })).toBeNull()
+  expect(target.get({ [viteKey]: null })).toBeNull()
+  expect(target.get({ [viteKey]: undefined })).toBeNull()
+  expect(target.get({})).toBeNull()
 
-  expect(target.vite.getOrDefault({ [viteKey]: false }, true)).toBe(false)
-  expect(target.vite.getOrDefault({ [viteKey]: {} }, true)).toBe(true)
-  expect(target.vite.getOrDefault({}, true)).toBe(true)
+  expect(target.getOrDefault({ [viteKey]: false }, true)).toBe(false)
+  expect(target.getOrDefault({ [viteKey]: {} }, true)).toBe(true)
+  expect(target.getOrDefault({}, true)).toBe(true)
 
   expect(target.asEnv(true)).toEqual({ [viteKey]: 'true' })
   expect(target.asEnv(false)).toEqual({ [viteKey]: 'false' })
@@ -172,76 +173,71 @@ function testBooleanVariable(
 
 function testRecordVariable(
   target: Variable<Record<string, any>>,
-  viteKey: string,
+  key: string,
   expectedZod: ZodType<any>,
 ) {
-  expect(target.vite.key).toEqual(viteKey)
+  expect(target.key).toEqual(key)
 
-  expect(target.vite.get({ [viteKey]: true })).toBeNull()
-  expect(target.vite.get({ [viteKey]: 'true' })).toBeNull()
-  expect(target.vite.get({ [viteKey]: '4234' })).toBeNull()
-  expect(target.vite.get({ [viteKey]: 4234 })).toBeNull()
+  expect(target.get({ [key]: true })).toBeNull()
+  expect(target.get({ [key]: 'true' })).toBeNull()
+  expect(target.get({ [key]: '4234' })).toBeNull()
+  expect(target.get({ [key]: 4234 })).toBeNull()
 
-  expect(target.vite.get({ [viteKey]: { abc: '123' } })).toEqual({ abc: '123' })
-  expect(
-    target.vite.get({ [viteKey]: JSON.stringify({ abc: '123' }) }),
-  ).toEqual({ abc: '123' })
+  expect(target.get({ [key]: { abc: '123' } })).toEqual({ abc: '123' })
+  expect(target.get({ [key]: JSON.stringify({ abc: '123' }) })).toEqual({
+    abc: '123',
+  })
 
-  expect(target.vite.getOrDefault({ [viteKey]: false }, { abc: 123 })).toEqual({
+  expect(target.getOrDefault({ [key]: false }, { abc: 123 })).toEqual({
     abc: 123,
   })
-  expect(target.vite.getOrDefault({ [viteKey]: {} }, { abc: 123 })).toEqual({})
-  expect(target.vite.getOrDefault({}, { abc: 123 })).toEqual({ abc: 123 })
+  expect(target.getOrDefault({ [key]: {} }, { abc: 123 })).toEqual({})
+  expect(target.getOrDefault({}, { abc: 123 })).toEqual({ abc: 123 })
 
   expect(target.asEnv({ abc: 123 })).toEqual({
-    [viteKey]: JSON.stringify({ abc: 123 }),
+    [key]: JSON.stringify({ abc: 123 }),
   })
-  expect(target.asEnv({})).toEqual({ [viteKey]: '{}' })
+  expect(target.asEnv({})).toEqual({ [key]: '{}' })
 
   ensureZodTypeEqual(target, expectedZod)
 }
 
 function testArrayVariable(
   target: Variable<Array<any>>,
-  viteKey: string,
+  key: string,
   expectedZod: ZodType<any>,
 ) {
-  expect(target.vite.key).toEqual(viteKey)
+  expect(target.key).toEqual(key)
 
-  expect(target.vite.get({ [viteKey]: true })).toBeNull()
-  expect(target.vite.get({ [viteKey]: 'true' })).toBeNull()
-  expect(target.vite.get({ [viteKey]: '4234' })).toBeNull()
-  expect(target.vite.get({ [viteKey]: 4234 })).toBeNull()
-  expect(target.vite.get({ [viteKey]: {} })).toBeNull()
+  expect(target.get({ [key]: true })).toBeNull()
+  expect(target.get({ [key]: 'true' })).toBeNull()
+  expect(target.get({ [key]: '4234' })).toBeNull()
+  expect(target.get({ [key]: 4234 })).toBeNull()
+  expect(target.get({ [key]: {} })).toBeNull()
 
-  expect(target.vite.get({ [viteKey]: [{ abc: '123' }] })).toEqual([
+  expect(target.get({ [key]: [{ abc: '123' }] })).toEqual([{ abc: '123' }])
+  expect(target.get({ [key]: JSON.stringify([{ abc: '123' }]) })).toEqual([
     { abc: '123' },
   ])
-  expect(
-    target.vite.get({ [viteKey]: JSON.stringify([{ abc: '123' }]) }),
-  ).toEqual([{ abc: '123' }])
 
-  expect(
-    target.vite.getOrDefault({ [viteKey]: false }, [{ abc: 123 }]),
-  ).toEqual([
+  expect(target.getOrDefault({ [key]: false }, [{ abc: 123 }])).toEqual([
     {
       abc: 123,
     },
   ])
-  expect(target.vite.getOrDefault({ [viteKey]: [] }, [{ abc: 123 }])).toEqual(
-    [],
-  )
-  expect(target.vite.getOrDefault({}, [{ abc: 123 }])).toEqual([{ abc: 123 }])
+  expect(target.getOrDefault({ [key]: [] }, [{ abc: 123 }])).toEqual([])
+  expect(target.getOrDefault({}, [{ abc: 123 }])).toEqual([{ abc: 123 }])
 
   expect(target.asEnv([{ abc: 123 }])).toEqual({
-    [viteKey]: JSON.stringify([{ abc: 123 }]),
+    [key]: JSON.stringify([{ abc: 123 }]),
   })
-  expect(target.asEnv([])).toEqual({ [viteKey]: '[]' })
+  expect(target.asEnv([])).toEqual({ [key]: '[]' })
 
   ensureZodTypeEqual(target, expectedZod)
 }
 
 function ensureZodTypeEqual(target: Variable<any>, expected: ZodType<any>) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
   // this does a good enough compare to make sure they have the same schema
   expect(JSON.parse(JSON.stringify(target.zod.type(z)))).toEqual(