tungsten 0.1.7 → 0.1.24

package/dist/routing/matchPath.js

@@ -0,0 +1,60 @@
+import { compareRequestToRegex } from "./compareRequestToRegex.js";
+import { patternToRegex } from "./patternToRegex.js";
+export function matchPath(pattern, request) {
+  // pathToRegexp(path, keys?, options?)
+  // match(path)
+  // parse(path)
+  // compile(path)
+  const {
+    regex,
+    keys
+  } = patternToRegex(pattern);
+  // we can get path priority, then prefer high ranked paths
+  //const priority = getPathPriority(pattern)
+  const {
+    success,
+    params
+  } = compareRequestToRegex(request, regex, keys);
+  //console.log('regex', regex, 'keys', keys, 'success', success)
+  if (success) {
+    return {
+      pattern,
+      request,
+      params
+    };
+  }
+  return null;
+  // const result = regex.exec(request)
+  // console.log('pattern', pattern, 'pathname', pathname)
+  // if (typeof pattern === 'string') {
+  //     pattern = {
+  //         path: pattern,
+  //         caseSensitive: false,
+  //         end: true
+  //     }
+  // }
+  // const [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end)
+  // console.log('matcher', matcher, 'paramNames', paramNames)
+  // const match = pathname.match(matcher)
+  // if (!match) return null
+  // const matchedPathname = match[0]
+  // let pathnameBase = matchedPathname.replace(/(.)\/+$/, '$1')
+  // const captureGroups = match.slice(1)
+  // const params = (paramNames as string[]/* put in to satisfy TS - trusting that code from RRv6 works as is */)
+  //     .reduce((memo, paramName, index) => {
+  //         // We need to compute the pathnameBase here using the raw splat value
+  //         // instead of using params["*"] later because it will be decoded then
+  //         if (paramName === '*') {
+  //             const splatValue = captureGroups[index] || ''
+  //             pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, '$1')
+  //         }
+  //         memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || '', paramName)
+  //         return memo
+  //     }, {})
+  // return {
+  //     params,
+  //     pathname: matchedPathname,
+  //     pathnameBase,
+  //     pattern
+  // }
+}

package/dist/routing/matchPath.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=matchPath.sxyt.d.ts.map

package/dist/routing/matchPath.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchPath.sxyt.d.ts","sourceRoot":"","sources":["../../src/routing/matchPath.sxyt.ts"],"names":[],"mappings":""}

package/dist/routing/matchPath.sxyt.js

@@ -0,0 +1,18 @@
+import { describe } from 'sxy-test-runner';
+import { expect } from 'chai';
+import { matchPath } from "./matchPath.js";
+describe('routing/matchPath()', ({
+  it
+}) => {
+  it(`returns null for /foo against /bar`, () => {
+    expect(matchPath('/foo', '/bar')).to.equal(null);
+  });
+  it(`returns match object for /foo against /foo`, () => {
+    const match = matchPath('/foo', '/foo');
+    expect(match).not.to.equal(null);
+  });
+  it(`returns match object for /foo/ against /foo`, () => {
+    const match = matchPath('/foo/', '/foo');
+    expect(match).not.to.equal(null);
+  });
+});

package/dist/routing/patternToRegex.d.ts

@@ -0,0 +1,5 @@
+export declare function patternToRegex(pattern: string): {
+    regex: RegExp;
+    keys: string[];
+};
+//# sourceMappingURL=patternToRegex.d.ts.map

package/dist/routing/patternToRegex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patternToRegex.d.ts","sourceRoot":"","sources":["../../src/routing/patternToRegex.ts"],"names":[],"mappings":"AAEA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CA2FjF"}

package/dist/routing/patternToRegex.js

@@ -0,0 +1,96 @@
+import { throwError } from "../throwError.js";
+export function patternToRegex(pattern) {
+  // regex: find params like :param 
+  const paramLookupRegex = /:[a-zA-Z_]+[a-zA-Z_0-9]*/g;
+  // match may return null, if so swap that for an empty array, then take of the : before the param (':id' -> 'id')
+  const keys = (pattern.match(paramLookupRegex) || []).map(x => x.slice(1));
+  // replace any clean params with a simple match group
+  // regex: find params like :param followed by / or end
+  const cleanParamLookupRegex = /:[a-zA-Z_]+[a-zA-Z_0-9]*(?=\/|$)/g;
+  pattern = pattern.replaceAll(cleanParamLookupRegex, '([^/]+)');
+  // replace any typed params with a suitable match group
+  // regex: find params like :param followed by <type>, where type is a string
+  const typedParamFullLookupRegex = /:[a-zA-Z_]+[a-zA-Z_0-9]*<[a-z0-9][a-z0-9-+]*>/g;
+  const typedParameters = pattern.match(typedParamFullLookupRegex);
+  //console.log('typedParameters', typedParameters)
+  if (typedParameters !== null) {
+    for (const p of typedParameters) {
+      //console.log('p', p)
+      const match = p.match(/(?<=<)[a-z0-9][a-z0-9-+]*(?=>)/);
+      if (match === null) throwError('patternToRegex()', `Could not find type in typed param '${p}'`);
+      const type = match[0];
+      let matchGroup = '';
+      switch (type) {
+        case 'digits':
+        case 'uint':
+        case 'unsigned-integer':
+          {
+            matchGroup = '(\\d+)';
+            break;
+          }
+        case 'int':
+        case 'integer':
+        case 'sint':
+        case 'signed-integer':
+          {
+            matchGroup = '(-?\\d+)';
+            break;
+          }
+        case 'int-ge1':
+        case '1+':
+          {
+            matchGroup = '([1-9]\\d*)';
+            break;
+          }
+        case 'num':
+        case 'number':
+          {
+            matchGroup = '(-?\\d+(?:\\.\\d+)?)';
+            break;
+          }
+        case 'alpha':
+          {
+            matchGroup = '([a-zA-Z]+)';
+            break;
+          }
+        case 'alpha-lower':
+          {
+            matchGroup = '([a-z]+)';
+            break;
+          }
+        case 'alpha-num':
+        case 'alpha-numeric':
+          {
+            matchGroup = '([a-zA-Z0-9]+)';
+            break;
+          }
+        case 'alpha-lower-num':
+        case 'alpha-lower-numeric':
+          {
+            matchGroup = '([a-z0-9]+)';
+            break;
+          }
+        default:
+          {
+            throwError('patternToRegex', `Unknown param type '${type}'`);
+          }
+      }
+      //console.log('pattern', pattern)
+      //console.log('p', p)
+      //console.log('matchGroup', matchGroup)
+      pattern = pattern.replace(p, matchGroup);
+    }
+  }
+  // remove the params that are explicitly defined, leaving just the given match groups
+  // regex: find params like :param followed by a regex match group like ()
+  const explicitParamLookupRegex = /:[a-zA-Z_]+[a-zA-Z_0-9]*(?=\([^)]+\))/g;
+  pattern = pattern.replaceAll(explicitParamLookupRegex, '');
+  // add start and end qualifiers to the pattern
+  pattern = '^' + pattern;
+  if (pattern.endsWith('/')) pattern += '?$';else pattern += '/?$';
+  const regex = new RegExp(pattern);
+  return {
+    regex,
+    keys
+  };
+}

package/dist/routing/patternToRegex.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=patternToRegex.sxyt.d.ts.map

package/dist/routing/patternToRegex.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patternToRegex.sxyt.d.ts","sourceRoot":"","sources":["../../src/routing/patternToRegex.sxyt.ts"],"names":[],"mappings":""}

package/dist/routing/patternToRegex.sxyt.js

@@ -0,0 +1,69 @@
+import { describe } from 'sxy-test-runner';
+import { patternToRegex } from "./patternToRegex.js";
+import { regexEquals } from "../_testing/regexEquals.js";
+describe('routing/patternToRegex()', ({
+  it
+}) => {
+  it(`Converts /foo to /^\\/foo\\/?$/ with no keys`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo');
+    regexEquals(regex, /^\/foo\/?$/).should.equal(true);
+    keys.length.should.equal(0);
+  });
+  it(`Converts /foo/:bar to /^\\/foo\\/([^/]+)\\/?$/ and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar');
+    regexEquals(regex, /^\/foo\/([^/]+)\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+  it(`Converts /foo/:bar(\\d+) to /^\\/foo\\/(\\d+)\\/?$/, preserving the regex matcher, and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar(\\d+)');
+    regexEquals(regex, /^\/foo\/(\d+)\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+  it(`Converts /foo/:bar/baz to /^\\/foo\\/([^/]+)\\/baz/?$/ and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar/baz');
+    regexEquals(regex, /^\/foo\/([^/]+)\/baz\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+  it(`Converts /foo/:bar<digits> to /^\\/foo\\/(\\d+)\\/?$/ and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar<digits>');
+    regexEquals(regex, /^\/foo\/(\d+)\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+  it(`Converts /foo/:bar<int-ge1> to /^\\/foo\\/([1-9]\\d*)\\/?$/ and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar<int-ge1>');
+    regexEquals(regex, /^\/foo\/([1-9]\d*)\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+  it(`Converts /foo/:bar<1+> to /^\\/foo\\/([1-9]\\d*)\\/?$/ and saves the key "bar"`, () => {
+    const {
+      regex,
+      keys
+    } = patternToRegex('/foo/:bar<1+>');
+    regexEquals(regex, /^\/foo\/([1-9]\d*)\/?$/).should.equal(true);
+    keys.length.should.equal(1);
+    keys[0].should.equal('bar');
+  });
+});

package/dist/routing/registerGlobalData.d.ts

@@ -0,0 +1,7 @@
+import type { ReqRes } from '../ReqRes.js';
+export interface GlobalData {
+}
+export type GlobalDataFunction = (reqRes: ReqRes) => Promise<GlobalData>;
+export declare let globalDataFunc: GlobalDataFunction | undefined;
+export declare function registerGlobalData(func: GlobalDataFunction): void;
+//# sourceMappingURL=registerGlobalData.d.ts.map

package/dist/routing/registerGlobalData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerGlobalData.d.ts","sourceRoot":"","sources":["../../src/routing/registerGlobalData.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,MAAM,WAAW,UAAU;CAAG;AAE9B,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;AAExE,eAAO,IAAI,cAAc,EAAE,kBAAkB,GAAG,SAAqB,CAAA;AAErE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,QAE1D"}

package/dist/routing/registerGlobalData.js

@@ -0,0 +1,4 @@
+export let globalDataFunc = undefined;
+export function registerGlobalData(func) {
+  globalDataFunc = func;
+}

package/dist/run.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

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

package/dist/run.js

@@ -0,0 +1 @@
+export {};

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+export * from './auth/index.js';
+export * from './cliOutput.js';
+export * from './spawnShellCommand.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,wBAAwB,CAAA"}

package/dist/server.js

@@ -0,0 +1,3 @@
+export * from "./auth/index.js";
+export * from "./cliOutput.js";
+export * from "./spawnShellCommand.js";

package/dist/serverRpc.d.ts

@@ -0,0 +1,2 @@
+export declare function serverRpc(parent: any, key: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+//# sourceMappingURL=serverRpc.d.ts.map

package/dist/serverRpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverRpc.d.ts","sourceRoot":"","sources":["../src/serverRpc.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,GAAG,kBAAkB,CAEtG"}

package/dist/serverRpc.js

@@ -0,0 +1,3 @@
+export function serverRpc(parent, key, descriptor) {
+  return descriptor;
+}

package/dist/serverRpcs.d.ts

@@ -0,0 +1,3 @@
+import type { ServerRpcFunction } from './ServerRpcFunction.type.js';
+export declare const serverRpcs: Record<string, ServerRpcFunction>;
+//# sourceMappingURL=serverRpcs.d.ts.map

package/dist/serverRpcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverRpcs.d.ts","sourceRoot":"","sources":["../src/serverRpcs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAEpE,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAM,CAAA"}

package/dist/serverRpcs.js

@@ -0,0 +1 @@
+export const serverRpcs = {};

package/dist/settings.d.ts

@@ -0,0 +1,20 @@
+export declare const buildFolder = ".tungsten";
+export declare const devBuildFolder = ".tungsten/dev";
+export declare const prodBuildFolder = ".tungsten/prod";
+export declare const bundleFolder = ".tungsten/prod/.bundle";
+export declare const staticSiteFolder = ".tungsten/staticSite";
+export declare const packagesCacheFolder = ".tungsten/packagesCache";
+export declare const packagesCacheInfoName = "info.json";
+export declare const serverFolder = "server";
+export declare const clientFolder = ".client";
+export declare const staticFolder = ".static";
+export declare const publicFolder = ".public";
+export declare const assetsFolder = ".assets";
+export declare const componentCssFolder = ".componentCss";
+export declare const componentCssFile = "css.css";
+export declare const packagesFolder = ".packages";
+export declare const packageName = "tungsten";
+export declare const packageNameCapitalized = "Tungsten";
+export declare const frameworkClientFolder = "_client";
+export declare const frameworkDistFolder = "dist";
+//# sourceMappingURL=settings.d.ts.map

package/dist/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,cAAc,CAAA;AACtC,eAAO,MAAM,cAAc,kBAAuB,CAAA;AAClD,eAAO,MAAM,eAAe,mBAAwB,CAAA;AACpD,eAAO,MAAM,YAAY,2BAA+B,CAAA;AACxD,eAAO,MAAM,gBAAgB,yBAA8B,CAAA;AAC3D,eAAO,MAAM,mBAAmB,4BAAiC,CAAA;AACjE,eAAO,MAAM,qBAAqB,cAAc,CAAA;AAChD,eAAO,MAAM,YAAY,WAAW,CAAA;AAEpC,eAAO,MAAM,YAAY,YAAY,CAAA;AACrC,eAAO,MAAM,YAAY,YAAY,CAAA;AACrC,eAAO,MAAM,YAAY,YAAY,CAAA;AACrC,eAAO,MAAM,YAAY,YAAY,CAAA;AACrC,eAAO,MAAM,kBAAkB,kBAAkB,CAAA;AACjD,eAAO,MAAM,gBAAgB,YAAY,CAAA;AACzC,eAAO,MAAM,cAAc,cAAc,CAAA;AAEzC,eAAO,MAAM,WAAW,aAAa,CAAA;AACrC,eAAO,MAAM,sBAAsB,aAAa,CAAA;AAChD,eAAO,MAAM,qBAAqB,YAAY,CAAA;AAC9C,eAAO,MAAM,mBAAmB,SAAS,CAAA"}

package/dist/settings.js

@@ -0,0 +1,20 @@
+export const buildFolder = '.tungsten';
+export const devBuildFolder = `${buildFolder}/dev`;
+export const prodBuildFolder = `${buildFolder}/prod`;
+export const bundleFolder = `${prodBuildFolder}/.bundle`;
+export const staticSiteFolder = `${buildFolder}/staticSite`;
+export const packagesCacheFolder = `${buildFolder}/packagesCache`;
+export const packagesCacheInfoName = `info.json`;
+export const serverFolder = 'server';
+//export const clientFolder = 'client'
+export const clientFolder = '.client';
+export const staticFolder = '.static';
+export const publicFolder = '.public';
+export const assetsFolder = '.assets';
+export const componentCssFolder = '.componentCss';
+export const componentCssFile = 'css.css';
+export const packagesFolder = '.packages';
+export const packageName = 'tungsten';
+export const packageNameCapitalized = 'Tungsten';
+export const frameworkClientFolder = '_client';
+export const frameworkDistFolder = 'dist';

package/dist/spawnShellCommand.d.ts

@@ -0,0 +1,3 @@
+import { SpawnOptionsWithoutStdio } from 'child_process';
+export declare function spawnShellCommand(command: string, extras: SpawnOptionsWithoutStdio): import("child_process").ChildProcessWithoutNullStreams;
+//# sourceMappingURL=spawnShellCommand.d.ts.map

package/dist/spawnShellCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnShellCommand.d.ts","sourceRoot":"","sources":["../src/spawnShellCommand.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAG/D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,0DAUlF"}

package/dist/spawnShellCommand.js

@@ -0,0 +1,12 @@
+import { spawn } from 'child_process';
+export function spawnShellCommand(command, extras) {
+  const parts = command.split(' '); // eslint-disable-line no-type-assertion/no-type-assertion -- split returns an array of length at least 1
+  // if (process.platform === 'win32') {
+  //     parts[0] += '.cmd'
+  // }
+  const options = {
+    shell: true,
+    ...extras
+  };
+  return spawn(parts[0], parts.slice(1), options);
+}

package/dist/standardizeWebPath.d.ts

@@ -0,0 +1,2 @@
+export declare function standardizeWebPath(path: string): string;
+//# sourceMappingURL=standardizeWebPath.d.ts.map

package/dist/standardizeWebPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardizeWebPath.d.ts","sourceRoot":"","sources":["../src/standardizeWebPath.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,UAI9C"}

package/dist/standardizeWebPath.js

@@ -0,0 +1,5 @@
+export function standardizeWebPath(path) {
+  if (!path.startsWith('/')) path = '/' + path;
+  if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
+  return path;
+}

package/dist/startDevServer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=startDevServer.d.ts.map

package/dist/startDevServer.d.ts.map

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

package/dist/startDevServer.js

@@ -0,0 +1,6 @@
+// import { DevServer } from './DevServer.js'
+export {};
+// export function startDevServer() {
+//     const devServer = new DevServer()
+//     devServer.start()
+// }

package/dist/staticGen/RouteDefinition.d.ts

@@ -0,0 +1,8 @@
+import type { RouteKey } from '../routing/RouteTypes.js';
+import type { ContentNode } from '../ContentNode.js';
+export type RouteDefinition = {
+    path: RouteKey;
+    content: ContentNode | string;
+    [key: string]: any;
+};
+//# sourceMappingURL=RouteDefinition.d.ts.map

package/dist/staticGen/RouteDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteDefinition.d.ts","sourceRoot":"","sources":["../../src/staticGen/RouteDefinition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,WAAW,GAAG,MAAM,CAAA;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACrB,CAAA"}

package/dist/staticGen/RouteDefinition.js

@@ -0,0 +1 @@
+export {};

package/dist/staticGen/getAppRoutes.d.ts

@@ -0,0 +1,4 @@
+import { FrameworkConfigComplete } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+export declare function getAppRoutes(compilationInfo: CompilationInfo, config: FrameworkConfigComplete): Promise<any>;
+//# sourceMappingURL=getAppRoutes.d.ts.map

package/dist/staticGen/getAppRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAppRoutes.d.ts","sourceRoot":"","sources":["../../src/staticGen/getAppRoutes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAIlE,wBAAsB,YAAY,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,uBAAuB,gBAoBnG"}

package/dist/staticGen/getAppRoutes.js

@@ -0,0 +1,18 @@
+import { join } from 'path';
+import { fixExtension } from "../fixExtension.js";
+import { TungstenError } from "../TungstenError.js";
+export async function getAppRoutes(compilationInfo, config) {
+  const fullBuildLocation = 'file://' + compilationInfo.location;
+  const routesLocationConfig = config.routesLocation;
+  try {
+    if (Array.isArray(routesLocationConfig)) {
+      const routesFile = fixExtension(join(fullBuildLocation, routesLocationConfig[0]));
+      return (await import(routesFile))[routesLocationConfig[1]];
+    } else {
+      const module = await import(join(fullBuildLocation, routesLocationConfig));
+      if ('routes' in module) return module.routes;else if ('default' in module) return module.default;else throw new TungstenError(`Err, no 'routes' or 'default' export found in routes file ${routesLocationConfig}`);
+    }
+  } catch (e) {
+    throw new TungstenError(`Error loading app routes. You can specify the location of your routes object in tungsten.config.js,` + ` e.g. routesLocation: ['Routes.jsx', 'routes'] (file, exportName)` + `\n${e}`);
+  }
+}

package/dist/staticGen/staticGen.d.ts

@@ -0,0 +1,3 @@
+import type { Framework } from '../Framework.js';
+export declare function staticGen(framework: Framework): Promise<void>;
+//# sourceMappingURL=staticGen.d.ts.map

package/dist/staticGen/staticGen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticGen.d.ts","sourceRoot":"","sources":["../../src/staticGen/staticGen.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAchD,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,iBA8JnD"}

package/dist/staticGen/staticGen.js

@@ -0,0 +1,136 @@
+import { existsSync, promises as fsPromises } from 'fs';
+import { join, dirname } from 'path';
+import fsExtra from 'fs-extra';
+import axios from 'axios';
+import { staticSiteFolder, staticFolder, assetsFolder, publicFolder, bundleFolder, componentCssFolder } from "../settings.js";
+import { getAppRoutes } from "./getAppRoutes.js";
+import { cliError, cliWarn } from "../cliOutput.js";
+import { matchPath } from "../routing/matchPath.js";
+import { throwError } from "../throwError.js";
+import { RouteKeyIsPath, StringIsPath } from "../routing/RouteTypes.js";
+import { findLinks, pathToLink, pathToFileName, rewriteLinks } from "./staticGenFunctions.js";
+export async function staticGen(framework) {
+  if (framework.compilationInfo === undefined) {
+    throwError('staticGen()', `framework.compilationInfo is undefined`);
+  }
+  const config = framework.config;
+  if (config === undefined) {
+    throwError('staticGen()', `expected framework.config to be set: ${framework.config}`);
+  }
+  const siteBasePath = config.siteBasePath;
+  console.log('siteBasePath', siteBasePath);
+  const projectDir = process.cwd();
+  let appRoutes = await getAppRoutes(framework.compilationInfo, config);
+  const buildLocation = framework.compilationInfo.location;
+  const server = await framework.createProdServer();
+  const serverLocation = await server.start(null, true); // port, mute
+  // ensure the target folder exists
+  await fsPromises.mkdir(join(projectDir, staticSiteFolder), {
+    recursive: true
+  });
+  const rewriteMap = {};
+  if (!Array.isArray(appRoutes)) {
+    appRoutes = Object.entries(appRoutes).map(([path, route]) => {
+      route.path = path;
+      return route;
+    });
+  }
+  // for default and 404 routes we need to identify which one is in use, and then make sure the app renders it
+  // appRoutes = appRoutes.map( route => {
+  //     if (route.path === 'default') {
+  //         route.path === '/__default'
+  //         cliWarn(`Static site gen turning default route into __default.html. It is possible that this could conflict with a real route.`)
+  //     } else if (route.path === '404') {
+  //         route.path === '/404'
+  //         cliWarn(`Static site gen turning 404 route into __404.html. It is possible that this could conflict with a real route.`)
+  //     } 
+  //     return route
+  // })
+  const dynamicRoutes = [];
+  appRoutes = appRoutes.filter(route => {
+    if (!route.path.startsWith('/')) {
+      //cliWarn(`Static gen skipping route ${route.path}, because it does not start with /, and is not default or 404`)
+      cliWarn(`Static gen skipping route ${route.path}, because it does not start with /`);
+      return false;
+    }
+    if (route.path.includes(':')) {
+      // separate these out
+      dynamicRoutes.push(route);
+      return false;
+    }
+    return true;
+  });
+  for (const route of appRoutes) {
+    // we need to develop the rewrite map over time, because we discover links during processing
+    const path = route.path;
+    rewriteMap[path] = pathToLink(path, siteBasePath);
+    console.log('rewriteMap', rewriteMap);
+  }
+  async function renderPath(path, siteBasePath) {
+    const url = serverLocation + path;
+    let links;
+    try {
+      console.log('get URL', url);
+      const response = await axios.get(url);
+      let result = response.data;
+      links = findLinks(result);
+      const newPaths = [];
+      for (const link of links) {
+        if (!StringIsPath(link)) throwError('renderRoute', `Found a link '${link}' that did not start with /`);
+        if (!(link in rewriteMap)) {
+          for (const dynamicRoute of dynamicRoutes) {
+            if (RouteKeyIsPath(dynamicRoute.path)) {
+              if (matchPath(dynamicRoute.path, link)) {
+                //console.log('link', link)
+                //console.log('in?', link in rewriteMap)
+                //console.log(`link ${link} matched dynamic route ${dynamicRoute.path}`)
+                newPaths.push(link);
+                rewriteMap[link] = pathToLink(link, siteBasePath);
+              }
+            } else {
+              // default
+              // 404
+            }
+          }
+        }
+      }
+      result = rewriteLinks(result, rewriteMap);
+      //const pageFileName = rewriteMap[path]
+      const pageFileName = pathToFileName(path);
+      const dest = join(projectDir, staticSiteFolder, pageFileName);
+      const dir = dirname(dest);
+      // ensure the target folder exists
+      // some duplication of effort here - oh well
+      await fsPromises.mkdir(dir, {
+        recursive: true
+      });
+      await fsPromises.writeFile(join(projectDir, staticSiteFolder, pageFileName), result);
+      // we can update the rewrite map here
+      // for (const route of appRoutes) { // we need to develop the rewrite map over time, because we discover links during processing
+      //     const path = route.path
+      //     rewriteMap[path] = pathToFileName(path)
+      // }
+      for (const link of newPaths) {
+        renderPath(link, siteBasePath);
+      }
+    } catch (e) {
+      cliError(`Static site gen - error generating path ${path} (full location ${url}): ${e} ${e.stack}`);
+    }
+  }
+  for (const route of appRoutes) {
+    await renderPath(route.path, siteBasePath);
+  }
+  console.log('rewriteMap', rewriteMap);
+  const copyPromises = [fsExtra.copy(join(buildLocation, staticFolder), join(projectDir, staticSiteFolder)),
+  // asset files - these may not exist - why this error if they don't? Probably
+  fsExtra.copy(join(buildLocation, assetsFolder), join(projectDir, staticSiteFolder, 'assets')),
+  // public files
+  existsSync(join(buildLocation, publicFolder)) ? fsExtra.copy(join(buildLocation, publicFolder), join(projectDir, staticSiteFolder)) : null,
+  // copy in the bundle
+  fsExtra.copy(join(projectDir, bundleFolder), join(projectDir, staticSiteFolder, 'bundle')),
+  // copy the client.js to clientWithEnv.js, because the framework looks for this file instead.
+  fsExtra.copy(join(projectDir, bundleFolder, 'client.js'), join(projectDir, bundleFolder, 'clientWithEnv.js')),
+  // copy in the css
+  fsExtra.copy(join(buildLocation, componentCssFolder), join(projectDir, staticSiteFolder, componentCssFolder))];
+  await Promise.all(copyPromises);
+}

package/dist/staticGen/staticGenFunctions.d.ts

@@ -0,0 +1,6 @@
+import { SiteBasePath as SiteBasePath } from '../render/HeadData.js';
+export declare function pathToFileName(path: string): string;
+export declare function pathToLink(path: string, siteBasePath: SiteBasePath): string;
+export declare function findLinks(content: string): string[];
+export declare function rewriteLinks(content: string, rewriteMap: Record<string, string>): string;
+//# sourceMappingURL=staticGenFunctions.d.ts.map