tungsten 0.4.9 → 0.4.11

package/dist/build/compileUserApp.js

@@ -9,7 +9,7 @@ import { writeFrameworkCss } from "./frameworkStylesheets.js";
 import { emitReloadEvent } from "../hmr/liveReloadHub.js";
 import { createTimeProfiler } from "../timeProfiler.js";
 //import { compileEnv } from './compileEnv.js'
-export async function compileUserApp(projectDir, appConfig, mode, profiler = createTimeProfiler(false), quiet = false) {
+export async function compileUserApp(projectDir, appConfig, mode, profiler = createTimeProfiler(false), quiet = false, tests = false) {
   const codeLocation = join(projectDir, appConfig.codeDir);
   const relSourceDir = appConfig.sourceDir !== undefined && appConfig.sourceDir !== '' ? appConfig.sourceDir : appConfig.codeDir;
   const sourceLocation = join(projectDir, relSourceDir);
@@ -22,12 +22,14 @@ export async function compileUserApp(projectDir, appConfig, mode, profiler = cre
   const watch = mode === 'dev';
   const compileJavascriptPromise = profiler.timeProfileAsync('compile javascript', () => compileJavascript(projectDir, appConfig, codeLocation, sourceLocation, styleImportBase, buildLocation, buildCodeLocation, mode, watch, mode === 'dev' ? {
     quiet,
+    tests,
     hmr: appConfig.hmr === true,
     onCycleComplete: cycle => {
       if (cycle.success) emitReloadEvent('js', cycle.file);
     }
   } : {
-    quiet
+    quiet,
+    tests
   }));
   //const compileEnvPromise = compileEnv(projectDir, appConfig, codeLocation, buildLocation, mode)
   const compileStylesPromise = profiler.timeProfileAsync('compile styles', () => compileStyles(projectDir, appConfig, styleImportBase, buildLocation, watch, mode === 'dev' ? () => emitReloadEvent('css') : undefined, quiet));

package/dist/build/sassImportParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sassImportParser.d.ts","sourceRoot":"","sources":["../../src/build/sassImportParser.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,YAAY,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA6R7D"}
+{"version":3,"file":"sassImportParser.d.ts","sourceRoot":"","sources":["../../src/build/sassImportParser.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,YAAY,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CAkS7D"}

package/dist/build/sassImportParser.js

@@ -1,4 +1,5 @@
 /* eslint-disable no-inner-declarations */
+import { cliLog } from "../cliOutput.js";
 import { throwError } from "../throwError.js";
 function debug(...texts) {
   //console.log(...texts)
@@ -161,7 +162,9 @@ export function sassImportParser(code) {
               } else if (/\S/.test(char)) {
                 if (statement === 'selector') {
                   if (IndentationIsValidIndentationOrThrow(indentation)) {
-                    if (firstLevelIndentation === null) throw new Error('internal error: firstLevelIndentation was null when comparing indentation');
+                    if (firstLevelIndentation === null) {
+                      throwError('sassImportParser', 'internal error: firstLevelIndentation was null when comparing indentation');
+                    }
                     const result = compareIndentation(indentation, firstLevelIndentation);
                     if (result === 1) {
                       mode = 'style-rules';
@@ -290,7 +293,7 @@ export function sassImportParser(code) {
     }
     return imports;
   } catch (e) {
-    console.log(e); //throw e
+    cliLog(e); //throw e
     throwError('sassImportParser', 'threw an error');
   }
 }

package/dist/build/tallyBabelPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { PluginItem } from '@babel/core';
+export declare function tallyBabelPlugins(plugins: PluginItem[] | null | undefined): PluginItem[];
+//# sourceMappingURL=tallyBabelPlugins.d.ts.map

package/dist/build/tallyBabelPlugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tallyBabelPlugins.d.ts","sourceRoot":"","sources":["../../src/build/tallyBabelPlugins.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AA+DxD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,EAAE,CAUxF"}

package/dist/build/tallyBabelPlugins.js

@@ -0,0 +1,68 @@
+import { tally } from "../timeProfiler.js";
+function wrapHandler(name, handler) {
+  return function (...args) {
+    const start = performance.now();
+    try {
+      return handler.apply(this, args);
+    } finally {
+      tally(name, performance.now() - start);
+    }
+  };
+}
+function wrapVisitor(name, visitor) {
+  const wrapped = {};
+  for (const [nodeType, handler] of Object.entries(visitor)) {
+    if (typeof handler === 'function') {
+      wrapped[nodeType] = wrapHandler(name, handler);
+    } else if (typeof handler === 'object' && handler !== null) {
+      const pair = handler;
+      const wrappedPair = {};
+      if (typeof pair.enter === 'function') wrappedPair.enter = wrapHandler(name, pair.enter);
+      if (typeof pair.exit === 'function') wrappedPair.exit = wrapHandler(name, pair.exit);
+      wrapped[nodeType] = wrappedPair;
+    } else {
+      wrapped[nodeType] = handler;
+    }
+  }
+  return wrapped;
+}
+// the plugin's own name where it declares one, else the factory's function name, else its position
+function wrapPluginObject(plugin, fallback) {
+  if (typeof plugin.visitor !== 'object') return plugin;
+  const name = `babel: ${plugin.name ?? fallback}`;
+  return {
+    ...plugin,
+    visitor: wrapVisitor(name, plugin.visitor)
+  };
+}
+// An entry is a plugin object, a factory babel calls to get one, or either of those paired with
+// options. A factory has to be wrapped around its result, since the object does not exist yet.
+function wrapEntry(entry, index) {
+  if (typeof entry === 'function') {
+    const factory = entry;
+    const fallback = factory.name === '' ? `plugin ${index}` : factory.name;
+    return function (...args) {
+      return wrapPluginObject(factory.apply(this, args), fallback);
+    };
+  }
+  if (typeof entry === 'object' && entry !== null && 'visitor' in entry) {
+    return wrapPluginObject(entry, `plugin ${index}`);
+  }
+  // a compiled-from-typescript plugin imported from esm arrives as its module namespace,
+  // { __esModule, default } - babel unwraps that itself, so the tally has to as well
+  if (typeof entry === 'object' && entry !== null && 'default' in entry) {
+    return wrapEntry(entry.default, index);
+  }
+  return entry;
+}
+export function tallyBabelPlugins(plugins) {
+  if (plugins === null || plugins === undefined) return [];
+  return plugins.map((item, index) => {
+    // [plugin, options] keeps its options; only the plugin half is wrapped
+    if (Array.isArray(item)) {
+      const [plugin, ...rest] = item;
+      return [wrapEntry(plugin, index), ...rest];
+    }
+    return wrapEntry(item, index);
+  });
+}

package/dist/env/getEnvSchemas.d.ts

@@ -1,9 +1,9 @@
 import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
-import { ZodType } from 'zod';
+import { type StandardSchema } from '../standardSchema.js';
 import { TungstenEnv } from './types.js';
 export type EnvSchemas = {
-    privateEnvSchema?: ZodType<TungstenEnv & TungstenPrivateEnv>;
-    publicEnvSchema?: ZodType<TungstenEnv & TungstenPublicEnv>;
+    privateEnvSchema?: StandardSchema<TungstenEnv & TungstenPrivateEnv>;
+    publicEnvSchema?: StandardSchema<TungstenEnv & TungstenPublicEnv>;
 };
 export declare function getEnvSchemas(config: FrameworkConfigComplete, iteration: number, dev: 'dev'): Promise<EnvSchemas>;
 export declare function getEnvSchemas(config: FrameworkConfigComplete, iteration?: null, dev?: 'prod'): Promise<EnvSchemas>;

package/dist/env/getEnvSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEnvSchemas.d.ts","sourceRoot":"","sources":["../../src/env/getEnvSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAK7B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAGxC,MAAM,MAAM,UAAU,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC,WAAW,GAAG,iBAAiB,CAAC,CAAC;CAC9D,CAAA;AAKD,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAChG,OAAO,CAAC,UAAU,CAAC,CAAA;AACrB,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,MAAM,GACjG,OAAO,CAAC,UAAU,CAAC,CAAA;AAoErB,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,uBAGlF"}
+{"version":3,"file":"getEnvSchemas.d.ts","sourceRoot":"","sources":["../../src/env/getEnvSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAEpE,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAKjF,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAGxC,MAAM,MAAM,UAAU,GAAG;IACrB,gBAAgB,CAAC,EAAE,cAAc,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC;IACpE,eAAe,CAAC,EAAE,cAAc,CAAC,WAAW,GAAG,iBAAiB,CAAC,CAAC;CACrE,CAAA;AAKD,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAChG,OAAO,CAAC,UAAU,CAAC,CAAA;AACrB,wBAAsB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,MAAM,GACjG,OAAO,CAAC,UAAU,CAAC,CAAA;AAmDrB,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,uBAGlF"}

package/dist/env/getEnvSchemas.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import { checkIsStandardSchema } from "../standardSchema.js";
 import { fixExtension } from "../fixExtension.js";
 import { throwError } from "../throwError.js";
 import { iterationQueryString } from "../iterationQueryString.js";
@@ -22,27 +23,20 @@ export async function getEnvSchemas(config, iteration = null, mode = 'prod') {
       module = await import(fullFilePath);
     }
     const envSchemas = {};
-    /// TODO: replace schemas with validator functions?
-    // validatePrivateEnv and validatePublicEnv?
+    // Any Standard Schema library will do, and the schema is only asked to validate - so there
+    // is nothing to check here beyond the protocol. That it produces an object is checked
+    // where it runs, against what it actually returned.
     if ('privateEnvSchema' in module) {
-      const schema = module.privateEnvSchema;
-      //console.log('private schema', typeof schema, schema.name, schema.constructor.name, schema)           
-      if (!(schema !== null && typeof schema === 'object' && schema.constructor.name === 'ZodObject')) {
-        throwError('getEnvSchemas()', `privateEnvSchema is not an instance of ZodObject. Found type of '${typeof schema}'.` + (typeof schema === 'object' ? ` constructor name '${schema.constructor.name}'` : '') + (typeof schema === 'function' ? ` name '${schema.name}'` : ''));
-      }
-      envSchemas.privateEnvSchema = schema;
+      checkIsStandardSchema('getEnvSchemas()', 'privateEnvSchema', module.privateEnvSchema);
+      envSchemas.privateEnvSchema = module.privateEnvSchema;
     }
     if ('publicEnvSchema' in module) {
-      const schema = module.publicEnvSchema;
-      //console.log('public schema', typeof schema, schema.name, schema.constructor.name, schema)  
-      if (!(schema !== null && typeof schema === 'object' && schema.constructor.name === 'ZodObject')) {
-        throwError('getEnvSchemas()', `publicEnvSchema is not an instance of ZodObject. Found type of '${typeof schema}'.` + (typeof schema === 'object' ? ` constructor name '${schema.constructor.name}'` : '') + (typeof schema === 'function' ? ` name '${schema.name}'` : ''));
-      }
-      envSchemas.publicEnvSchema = schema;
+      checkIsStandardSchema('getEnvSchemas()', 'publicEnvSchema', module.publicEnvSchema);
+      envSchemas.publicEnvSchema = module.publicEnvSchema;
     }
     return envSchemas;
   } catch (e) {
-    throwError('getEnvSchemas()', `Error loading env schemas file` + `\n${e}` + `\nExpected to find a file with Zod schemas at ${envSchemasLocation}` + `\nThis location is set with the envSchemasLocations setting in tungsten.config.js`);
+    throwError('getEnvSchemas()', `Error loading env schemas file` + `\n${e}` + `\nExpected to find a file with env schemas at ${envSchemasLocation}` + `\nThis location is set with the envSchemasLocations setting in tungsten.config.js`);
   }
 }
 //export function getEnvSchemasDev(config: FrameworkConfigComplete, load: Load) {

package/dist/env/setPrivateEnvValidator.d.ts

@@ -1,6 +1,6 @@
-import type { ZodObject } from 'zod';
+import type { StandardSchema } from '../standardSchema.js';
 export type TungstenPrivateEnvValidatorFunction = () => TungstenPrivateEnv;
-export type TungstenPrivateEnvValidator = TungstenPrivateEnvValidatorFunction | ZodObject<any>;
+export type TungstenPrivateEnvValidator = TungstenPrivateEnvValidatorFunction | StandardSchema<TungstenPrivateEnv>;
 declare global {
     var __tungstenPrivateEnvValidator: TungstenPrivateEnvValidator | undefined;
 }

package/dist/env/setPrivateEnvValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setPrivateEnvValidator.d.ts","sourceRoot":"","sources":["../../src/env/setPrivateEnvValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,MAAM,MAAM,mCAAmC,GAAG,MAAM,kBAAkB,CAAA;AAC1E,MAAM,MAAM,2BAA2B,GAAG,mCAAmC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;AAE9F,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,6BAA6B,EAAE,2BAA2B,GAAG,SAAS,CAAA;CAC7E;AAGD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,2BAA2B,QAE5E"}
+{"version":3,"file":"setPrivateEnvValidator.d.ts","sourceRoot":"","sources":["../../src/env/setPrivateEnvValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,MAAM,MAAM,mCAAmC,GAAG,MAAM,kBAAkB,CAAA;AAC1E,MAAM,MAAM,2BAA2B,GACjC,mCAAmC,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAA;AAE9E,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,6BAA6B,EAAE,2BAA2B,GAAG,SAAS,CAAA;CAC7E;AAGD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,2BAA2B,QAE5E"}

package/dist/env/setPublicEnvValidator.d.ts

@@ -1,6 +1,6 @@
-import type { ZodObject } from 'zod';
+import type { StandardSchema } from '../standardSchema.js';
 export type TungstenPublicEnvValidatorFunction = () => TungstenPrivateEnv;
-export type TungstenPublicEnvValidator = TungstenPublicEnvValidatorFunction | ZodObject<any>;
+export type TungstenPublicEnvValidator = TungstenPublicEnvValidatorFunction | StandardSchema<TungstenPrivateEnv>;
 declare global {
     var __tungstenPublicEnvValidator: TungstenPublicEnvValidator | undefined;
 }

package/dist/env/setPublicEnvValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setPublicEnvValidator.d.ts","sourceRoot":"","sources":["../../src/env/setPublicEnvValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,MAAM,MAAM,kCAAkC,GAAG,MAAM,kBAAkB,CAAA;AACzE,MAAM,MAAM,0BAA0B,GAAG,kCAAkC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;AAE5F,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,4BAA4B,EAAE,0BAA0B,GAAG,SAAS,CAAA;CAC3E;AAGD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,0BAA0B,QAE1E"}
+{"version":3,"file":"setPublicEnvValidator.d.ts","sourceRoot":"","sources":["../../src/env/setPublicEnvValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,MAAM,MAAM,kCAAkC,GAAG,MAAM,kBAAkB,CAAA;AACzE,MAAM,MAAM,0BAA0B,GAChC,kCAAkC,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAA;AAE7E,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,4BAA4B,EAAE,0BAA0B,GAAG,SAAS,CAAA;CAC3E;AAGD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,0BAA0B,QAE1E"}

package/dist/frameworkConfigSchema.d.ts

@@ -1,196 +1,65 @@
 import { ParserOptions as BabelParserOptions } from '@babel/parser';
 import { SiteBasePath } from './render/HeadData.js';
-declare const frameworkConfigWithRootComponentValidator: import("arktype/internal/variants/object.ts").ObjectType<{
-    codeDir?: string;
-    copy?: string;
-    exclude?: string;
-    copyExclude?: string;
-    sourceDir?: string;
-    publicDir?: string;
-    assetsDir?: string;
-    styleImportBase?: string;
-    siteBasePath?: "" | `/${string}`;
-    clientSideNav?: boolean;
-    staticSite?: boolean;
-    routesLocation?: [string, string];
-    envSchemasLocation?: string;
-    babelOptions?: {
-        allowImportExportEverywhere?: boolean;
-        allowAwaitOutsideFunction?: boolean;
-        allowReturnOutsideFunction?: boolean;
-        allowNewTargetOutsideFunction?: boolean;
-        allowSuperOutsideMethod?: boolean;
-        allowUndeclaredExports?: boolean;
-        annexB?: boolean;
-        attachComment?: boolean;
-        errorRecovery?: boolean;
-        sourceType?: "script" | "module" | "unambiguous";
-        sourceFilename?: string;
-        startLine?: number;
-        startColumn?: number;
-        plugins?: unknown[];
-        strictMode?: boolean;
-        ranges?: boolean;
-        tokens?: boolean;
-        createParenthesizedExpressions?: boolean;
-        createImportExpressions?: boolean;
-    };
-    packageSystem?: "rewrites" | "aliases";
-    ignoreDirs?: string | string[];
-    ignorePatterns?: string | string[];
-    skipPackageCompilation?: string | string[];
-    serverMiddleware?: [string, string, string];
-    apiRoutes?: string;
-    apiPath?: string;
-    csr?: boolean;
-    rootComponent: string;
-    useRootComponent?: true;
-}, {}>;
-declare const frameworkConfigWithoutRootComponentValidator: import("arktype/internal/variants/object.ts").ObjectType<{
-    codeDir?: string;
-    copy?: string;
-    exclude?: string;
-    copyExclude?: string;
-    sourceDir?: string;
-    publicDir?: string;
-    assetsDir?: string;
-    styleImportBase?: string;
-    siteBasePath?: "" | `/${string}`;
-    clientSideNav?: boolean;
-    staticSite?: boolean;
-    routesLocation?: [string, string];
-    envSchemasLocation?: string;
-    babelOptions?: {
-        allowImportExportEverywhere?: boolean;
-        allowAwaitOutsideFunction?: boolean;
-        allowReturnOutsideFunction?: boolean;
-        allowNewTargetOutsideFunction?: boolean;
-        allowSuperOutsideMethod?: boolean;
-        allowUndeclaredExports?: boolean;
-        annexB?: boolean;
-        attachComment?: boolean;
-        errorRecovery?: boolean;
-        sourceType?: "script" | "module" | "unambiguous";
-        sourceFilename?: string;
-        startLine?: number;
-        startColumn?: number;
-        plugins?: unknown[];
-        strictMode?: boolean;
-        ranges?: boolean;
-        tokens?: boolean;
-        createParenthesizedExpressions?: boolean;
-        createImportExpressions?: boolean;
-    };
-    packageSystem?: "rewrites" | "aliases";
-    ignoreDirs?: string | string[];
-    ignorePatterns?: string | string[];
-    skipPackageCompilation?: string | string[];
-    serverMiddleware?: [string, string, string];
-    apiRoutes?: string;
-    apiPath?: string;
-    csr?: boolean;
-    useRootComponent: false;
-}, {}>;
-export declare const frameworkConfigValidator: import("arktype/internal/variants/object.ts").ObjectType<{
-    codeDir?: string;
-    copy?: string;
-    exclude?: string;
-    copyExclude?: string;
-    sourceDir?: string;
-    publicDir?: string;
-    assetsDir?: string;
-    styleImportBase?: string;
-    siteBasePath?: "" | `/${string}`;
-    clientSideNav?: boolean;
-    staticSite?: boolean;
-    routesLocation?: [string, string];
-    envSchemasLocation?: string;
-    babelOptions?: {
-        allowImportExportEverywhere?: boolean;
-        allowAwaitOutsideFunction?: boolean;
-        allowReturnOutsideFunction?: boolean;
-        allowNewTargetOutsideFunction?: boolean;
-        allowSuperOutsideMethod?: boolean;
-        allowUndeclaredExports?: boolean;
-        annexB?: boolean;
-        attachComment?: boolean;
-        errorRecovery?: boolean;
-        sourceType?: "script" | "module" | "unambiguous";
-        sourceFilename?: string;
-        startLine?: number;
-        startColumn?: number;
-        plugins?: unknown[];
-        strictMode?: boolean;
-        ranges?: boolean;
-        tokens?: boolean;
-        createParenthesizedExpressions?: boolean;
-        createImportExpressions?: boolean;
-    };
-    packageSystem?: "rewrites" | "aliases";
-    ignoreDirs?: string | string[];
-    ignorePatterns?: string | string[];
-    skipPackageCompilation?: string | string[];
-    serverMiddleware?: [string, string, string];
-    apiRoutes?: string;
-    apiPath?: string;
-    csr?: boolean;
-    rootComponent: string;
-    useRootComponent?: true;
-} | {
-    codeDir?: string;
-    copy?: string;
-    exclude?: string;
-    copyExclude?: string;
-    sourceDir?: string;
-    publicDir?: string;
-    assetsDir?: string;
-    styleImportBase?: string;
-    siteBasePath?: "" | `/${string}`;
-    clientSideNav?: boolean;
-    staticSite?: boolean;
-    routesLocation?: [string, string];
-    envSchemasLocation?: string;
-    babelOptions?: {
-        allowImportExportEverywhere?: boolean;
-        allowAwaitOutsideFunction?: boolean;
-        allowReturnOutsideFunction?: boolean;
-        allowNewTargetOutsideFunction?: boolean;
-        allowSuperOutsideMethod?: boolean;
-        allowUndeclaredExports?: boolean;
-        annexB?: boolean;
-        attachComment?: boolean;
-        errorRecovery?: boolean;
-        sourceType?: "script" | "module" | "unambiguous";
-        sourceFilename?: string;
-        startLine?: number;
-        startColumn?: number;
-        plugins?: unknown[];
-        strictMode?: boolean;
-        ranges?: boolean;
-        tokens?: boolean;
-        createParenthesizedExpressions?: boolean;
-        createImportExpressions?: boolean;
-    };
-    packageSystem?: "rewrites" | "aliases";
-    ignoreDirs?: string | string[];
-    ignorePatterns?: string | string[];
-    skipPackageCompilation?: string | string[];
-    serverMiddleware?: [string, string, string];
-    apiRoutes?: string;
-    apiPath?: string;
-    csr?: boolean;
-    useRootComponent: false;
-}, {}>;
-type ArkFrameworkConfigWithRootComponent = typeof frameworkConfigWithRootComponentValidator.infer;
-type ArkFrameworkConfigWithoutRootComponent = typeof frameworkConfigWithoutRootComponentValidator.infer;
-interface FrameworkConfigWithRootComponent extends Omit<ArkFrameworkConfigWithRootComponent, 'siteBasePath' | 'babelOptions'> {
-    siteBasePath?: SiteBasePath;
-    babelOptions?: BabelParserOptions;
+import * as v from 'valibot';
+export interface BabelOptions extends BabelParserOptions {
 }
-interface FrameworkConfigWithoutRootComponent extends Omit<ArkFrameworkConfigWithoutRootComponent, 'siteBasePath' | 'babelOptions'> {
-    siteBasePath?: SiteBasePath;
-    babelOptions?: BabelParserOptions;
-}
-export type FrameworkConfig = FrameworkConfigWithRootComponent | FrameworkConfigWithoutRootComponent;
-export {};
+export declare const frameworkConfigValidator: v.VariantSchema<"useRootComponent", [v.ObjectSchema<{
+    readonly useRootComponent: v.ExactOptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+    readonly rootComponent: v.StringSchema<undefined>;
+    readonly codeDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly copy: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly exclude: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly copyExclude: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly sourceDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly publicDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly assetsDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly styleImportBase: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly siteBasePath: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>], undefined>, v.TransformAction<string, SiteBasePath>]>, undefined>;
+    readonly clientSideNav: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly staticSite: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly routesLocation: v.ExactOptionalSchema<v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    readonly envSchemasLocation: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly babelOptions: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.LooseObjectSchema<{}, undefined>, v.TransformAction<{} & {
+        [key: string]: unknown;
+    }, BabelOptions>]>, undefined>;
+    readonly packageSystem: v.ExactOptionalSchema<v.PicklistSchema<["rewrites", "aliases"], undefined>, undefined>;
+    readonly ignoreDirs: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly ignorePatterns: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly testDirs: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly testPatterns: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly skipPackageCompilation: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly serverMiddleware: v.ExactOptionalSchema<v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    readonly apiRoutes: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly apiPath: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly csr: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly useRootComponent: v.LiteralSchema<false, undefined>;
+    readonly codeDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly copy: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly exclude: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly copyExclude: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly sourceDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly publicDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly assetsDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly styleImportBase: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly siteBasePath: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>], undefined>, v.TransformAction<string, SiteBasePath>]>, undefined>;
+    readonly clientSideNav: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly staticSite: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly routesLocation: v.ExactOptionalSchema<v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    readonly envSchemasLocation: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly babelOptions: v.ExactOptionalSchema<v.SchemaWithPipe<readonly [v.LooseObjectSchema<{}, undefined>, v.TransformAction<{} & {
+        [key: string]: unknown;
+    }, BabelOptions>]>, undefined>;
+    readonly packageSystem: v.ExactOptionalSchema<v.PicklistSchema<["rewrites", "aliases"], undefined>, undefined>;
+    readonly ignoreDirs: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly ignorePatterns: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly testDirs: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly testPatterns: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly skipPackageCompilation: v.ExactOptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly serverMiddleware: v.ExactOptionalSchema<v.TupleSchema<[v.StringSchema<undefined>, v.StringSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    readonly apiRoutes: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly apiPath: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly csr: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+export type FrameworkConfig = v.InferOutput<typeof frameworkConfigValidator>;
 //# sourceMappingURL=frameworkConfigSchema.d.ts.map

package/dist/frameworkConfigSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frameworkConfigSchema.d.ts","sourceRoot":"","sources":["../src/frameworkConfigSchema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AA0DnD,QAAA,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAK7C,CAAA;AAEF,QAAA,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIhD,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEoB,CAAA;AAEzD,KAAK,mCAAmC,GAAG,OAAO,yCAAyC,CAAC,KAAK,CAAA;AACjG,KAAK,sCAAsC,GAAG,OAAO,4CAA4C,CAAC,KAAK,CAAA;AAIvG,UAAU,gCACN,SAAQ,IAAI,CAAC,mCAAmC,EAAE,cAAc,GAAG,cAAc,CAAC;IAClF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,UAAU,mCACN,SAAQ,IAAI,CAAC,sCAAsC,EAAE,cAAc,GAAG,cAAc,CAAC;IACrF,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,kBAAkB,CAAA;CACpC;AAED,MAAM,MAAM,eAAe,GAAG,gCAAgC,GAAG,mCAAmC,CAAA"}
+{"version":3,"file":"frameworkConfigSchema.d.ts","sourceRoot":"","sources":["../src/frameworkConfigSchema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGnD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,MAAM,WAAW,YAAa,SAAQ,kBAAkB;CAAG;AA4D3D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGnC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/frameworkConfigSchema.js

@@ -1,67 +1,54 @@
-import { type as arkType } from 'arktype';
-const babelParserOptionsType = arkType({
-  'allowImportExportEverywhere?': 'boolean',
-  'allowAwaitOutsideFunction?': 'boolean',
-  'allowReturnOutsideFunction?': 'boolean',
-  'allowNewTargetOutsideFunction?': 'boolean',
-  'allowSuperOutsideMethod?': 'boolean',
-  'allowUndeclaredExports?': 'boolean',
-  'annexB?': 'boolean',
-  'attachComment?': 'boolean',
-  'errorRecovery?': 'boolean',
-  'sourceType?': '"script" | "module" | "unambiguous"',
-  'sourceFilename?': 'string',
-  'startLine?': 'number',
-  'startColumn?': 'number',
-  //'plugins?': ParserPlugin[]
-  'plugins?': 'unknown[]',
-  'strictMode?': 'boolean',
-  'ranges?': 'boolean',
-  'tokens?': ' boolean',
-  'createParenthesizedExpressions?': 'boolean',
-  'createImportExpressions?': 'boolean'
-});
-const frameworkConfigBaseValidator = arkType({
-  'codeDir?': 'string',
-  'copy?': 'string',
-  'exclude?': 'string',
-  'copyExclude?': 'string',
-  'sourceDir?': 'string',
-  'publicDir?': 'string',
-  'assetsDir?': 'string',
-  'styleImportBase?': 'string',
-  //publicDir?: string
-  //siteBasePath?: "" | `/${string}`,
-  'siteBasePath?': '"" | /^\\/.*$/',
-  'clientSideNav?': 'boolean',
-  'staticSite?': 'boolean',
+// exactOptional, not optional, throughout: tsconfig has exactOptionalPropertyTypes, and optional()
+// widens the value to include undefined, which FrameworkConfig's consumers then reject
+import * as v from 'valibot';
+// shape only - babel validates its own options, and a hand-copied key list just drifts from theirs
+const babelParserOptionsSchema = v.pipe(v.looseObject({}),
+// eslint-disable-next-line no-type-assertion/no-type-assertion -- see above
+v.transform(options => options));
+const stringOrStrings = v.union([v.string(), v.array(v.string())]);
+const frameworkConfigBaseEntries = {
+  codeDir: v.exactOptional(v.string()),
+  copy: v.exactOptional(v.string()),
+  exclude: v.exactOptional(v.string()),
+  copyExclude: v.exactOptional(v.string()),
+  sourceDir: v.exactOptional(v.string()),
+  publicDir: v.exactOptional(v.string()),
+  assetsDir: v.exactOptional(v.string()),
+  styleImportBase: v.exactOptional(v.string()),
+  // valibot has no template-literal schema, so the regex proves what the cast then states
+  siteBasePath: v.exactOptional(v.pipe(v.union([v.literal(''), v.pipe(v.string(), v.regex(/^\/.*$/))]),
+  // eslint-disable-next-line no-type-assertion/no-type-assertion -- see above
+  v.transform(path => path))),
+  clientSideNav: v.exactOptional(v.boolean()),
+  staticSite: v.exactOptional(v.boolean()),
   // not ready // uniqueComponents?: boolean
   // not ready // bindMode?: BindMode
-  //appLocation: AppLocation
-  //useRootComponent: boolean
-  //rootComponent?: string
-  'routesLocation?': ['string', 'string'],
-  'envSchemasLocation?': 'string',
-  'babelOptions?': babelParserOptionsType,
-  'packageSystem?': '"rewrites" | "aliases"',
-  'ignoreDirs?': 'string | string[]',
+  routesLocation: v.exactOptional(v.tuple([v.string(), v.string()])),
+  envSchemasLocation: v.exactOptional(v.string()),
+  babelOptions: v.exactOptional(babelParserOptionsSchema),
+  packageSystem: v.exactOptional(v.picklist(['rewrites', 'aliases'])),
+  ignoreDirs: v.exactOptional(stringOrStrings),
   // rename to ignoreFolders?
-  'ignorePatterns?': 'string | string[]',
-  'skipPackageCompilation?': 'string | string[]',
-  'serverMiddleware?': ['string', 'string', 'string'],
-  'apiRoutes?': 'string',
-  'apiPath?': 'string',
-  'csr?': 'boolean'
-});
-const frameworkConfigWithRootComponentValidator = arkType({
-  '...': frameworkConfigBaseValidator,
-  // in an intersection, non-overlapping values at isAdmin would result in a ParseError
-  'useRootComponent?': 'true',
-  rootComponent: 'string'
+  ignorePatterns: v.exactOptional(stringOrStrings),
+  // test files: left out of every compile unless `tungsten compile --tests` asks for them -
+  // the same two shapes as ignoreDirs/ignorePatterns
+  testDirs: v.exactOptional(stringOrStrings),
+  testPatterns: v.exactOptional(stringOrStrings),
+  skipPackageCompilation: v.exactOptional(stringOrStrings),
+  serverMiddleware: v.exactOptional(v.tuple([v.string(), v.string(), v.string()])),
+  apiRoutes: v.exactOptional(v.string()),
+  apiPath: v.exactOptional(v.string()),
+  csr: v.exactOptional(v.boolean())
+};
+const frameworkConfigWithRootComponentSchema = v.object({
+  ...frameworkConfigBaseEntries,
+  useRootComponent: v.exactOptional(v.literal(true)),
+  rootComponent: v.string()
 });
-const frameworkConfigWithoutRootComponentValidator = arkType({
-  '...': frameworkConfigBaseValidator,
-  // in an intersection, non-overlapping values at isAdmin would result in a ParseError
-  'useRootComponent': 'false'
+const frameworkConfigWithoutRootComponentSchema = v.object({
+  ...frameworkConfigBaseEntries,
+  useRootComponent: v.literal(false)
 });
-export const frameworkConfigValidator = frameworkConfigWithRootComponentValidator.or(frameworkConfigWithoutRootComponentValidator);
+// variant, not union: a plain union reports one issue at the union itself ("Expected Object but
+// received Object"), where this picks the branch by useRootComponent and reports its actual fields
+export const frameworkConfigValidator = v.variant('useRootComponent', [frameworkConfigWithRootComponentSchema, frameworkConfigWithoutRootComponentSchema]);

package/dist/getUserConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUserConfig.d.ts","sourceRoot":"","sources":["../src/getUserConfig.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAMxF,wBAAsB,aAAa,CAC/B,SAAS,GAAE,wBAAwB,GAAG,IAAW,EACjD,MAAM,GAAE,QAAQ,GAAG,OAAiB,GACrC,OAAO,CAAC,uBAAuB,CAAC,CAyBlC"}
+{"version":3,"file":"getUserConfig.d.ts","sourceRoot":"","sources":["../src/getUserConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAOxF,wBAAsB,aAAa,CAC/B,SAAS,GAAE,wBAAwB,GAAG,IAAW,EACjD,MAAM,GAAE,QAAQ,GAAG,OAAiB,GACrC,OAAO,CAAC,uBAAuB,CAAC,CAsBlC"}