tungsten 0.2.0 → 0.2.2

package/dist/render/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/render/debug.ts"],"names":[],"mappings":"AACA,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,QAExC"}

package/dist/render/debug.js

@@ -0,0 +1,3 @@
+export function debug(...texts) {
+  //console.log(...texts)
+}

package/dist/render/functionComponentNodeToRenderingTree.d.ts

@@ -0,0 +1,6 @@
+import type { AnyComponent } from '../AnyComponent.js';
+import type { Instance } from '../Instance/Instance.js';
+import { type RenderingNodeComponent } from '../RenderingNode.js';
+import { ContentNodeFunctionComponent } from '../ContentNode.js';
+export declare function functionComponentNodeToRenderingTree(contentNode: ContentNodeFunctionComponent, parentComponent: AnyComponent | null, instance: Instance, noEscape: boolean): Promise<RenderingNodeComponent>;
+//# sourceMappingURL=functionComponentNodeToRenderingTree.d.ts.map

package/dist/render/functionComponentNodeToRenderingTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionComponentNodeToRenderingTree.d.ts","sourceRoot":"","sources":["../../src/render/functionComponentNodeToRenderingTree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EACH,KAAK,sBAAsB,EAE9B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA;AAKhE,wBAAsB,oCAAoC,CACtD,WAAW,EAAE,4BAA4B,EACzC,eAAe,EAAE,YAAY,GAAG,IAAI,EACpC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,GACtC,OAAO,CAAC,sBAAsB,CAAC,CAajC"}

package/dist/render/functionComponentNodeToRenderingTree.js

@@ -0,0 +1,15 @@
+import { makeRenderingNodeFunctionComponentFromContentNodeFunctionComponent } from "../RenderingNode.js";
+import { getStyledContentFromFunctionComponent } from "../getStyledContentFromFunctionComponent.js";
+import { contentTreeToRenderingTree } from "./contentTreeToRenderingTree.js";
+import { instantiateFunctionComponent } from "./instantiateFunctionComponent.js";
+import { setCurrentComponent } from 'tungsten/hooks/setCurrentComponent.js';
+import { clearCurrentComponent } from 'tungsten/hooks/clearCurrentComponent.js';
+export async function functionComponentNodeToRenderingTree(contentNode, parentComponent, instance, noEscape) {
+  const standIn = instantiateFunctionComponent(contentNode, parentComponent, instance);
+  //console.log('functionComponentToTree')
+  setCurrentComponent(standIn);
+  const content = await getStyledContentFromFunctionComponent(standIn);
+  //const content = await getStyledContentFromFunctionComponent(standIn.func, standIn.props)
+  clearCurrentComponent();
+  return makeRenderingNodeFunctionComponentFromContentNodeFunctionComponent(contentNode, standIn, await contentTreeToRenderingTree(content, parentComponent, instance, noEscape));
+}

package/dist/render/getFunctionBodyAsString.d.ts

@@ -0,0 +1,3 @@
+export declare function getFunctionBodyAsString(func: Function): string;
+export declare function getArrowFunctionBody(func: Function): string | null;
+//# sourceMappingURL=getFunctionBodyAsString.d.ts.map

package/dist/render/getFunctionBodyAsString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFunctionBodyAsString.d.ts","sourceRoot":"","sources":["../../src/render/getFunctionBodyAsString.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,UAcrD;AAID,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAgBlE"}

package/dist/render/getFunctionBodyAsString.js

@@ -0,0 +1,28 @@
+import { throwError } from "../throwError.js";
+export function getFunctionBodyAsString(func) {
+  const functionString = func.toString();
+  // if the function is a standard function
+  if (functionString.startsWith('function')) {
+    // return the function body
+    return functionString.slice(functionString.indexOf('{') + 1, functionString.lastIndexOf('}')).trim();
+  } else {
+    // the function is an arrow function
+    const body = getArrowFunctionBody(func);
+    if (body === null) throwError('getFunctionBodyAsString', `could not extract function body from function ${func.toString()}`);
+    return 'return ' + body + ';';
+  }
+}
+// doesn't prove that an arrow function was passed
+// might need a run time check
+export function getArrowFunctionBody(func) {
+  // Not sure about this RegEx, probably from google
+  const regex = /^(?:\s*\(?(?:\s*\w*\s*,?\s*)*\)?\s*?=>\s*){?([\s\S]*)}?$/;
+  const matches = func.toString().match(regex); // eslint-disable-line no-type-assertion/no-type-assertion -- regex has a capture group
+  if (!matches) {
+    return null;
+  }
+  const firstPass = matches[1];
+  // Needed because the RegExp doesn't handle the last '}'.
+  const secondPass = (firstPass.match(/{/g) || []).length === (firstPass.match(/}/g) || []).length - 1 ? firstPass.slice(0, firstPass.lastIndexOf('}')) : firstPass;
+  return secondPass;
+}

package/dist/render/getFunctionBodyAsString.sxyt.d.ts

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

package/dist/render/getFunctionBodyAsString.sxyt.d.ts.map

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

package/dist/render/getFunctionBodyAsString.sxyt.js

@@ -0,0 +1,37 @@
+import { describe } from 'sxy-test-runner';
+import { should as setupShould } from 'chai';
+const should = setupShould(); // eslint-disable-line @typescript-eslint/no-unused-vars
+import { getFunctionBodyAsString } from "./getFunctionBodyAsString.js";
+describe('getFunctionBodyAsString()', ({
+  it
+}) => {
+  it('should return the function body of a conventional function as a string', () => {
+    const func = function () {
+      return 'Hello World';
+    };
+    const body = getFunctionBodyAsString(func);
+    //console.log('body', body)
+    body.should.equal('return \'Hello World\';');
+  });
+  it('should handle multi line conventional functions', () => {
+    const func = function () {
+      return 'Hello World';
+    };
+    const body = getFunctionBodyAsString(func);
+    //console.log('body', body)
+    body.should.equal('return \'Hello World\';');
+  });
+  it('should return the function body of a braceless arrow function as a string', () => {
+    const func = () => 'Hello World';
+    const body = getFunctionBodyAsString(func);
+    //console.log('body', body)
+    body.should.equal('return \'Hello World\';');
+  });
+  it('should handle multi line braceless arrow functions', () => {
+    const func = () => 'Hello' + ' World';
+    const body = getFunctionBodyAsString(func);
+    //console.log('body', body)
+    body.should.equal('return \'Hello\' + \' World\';');
+    //body.should.equal('return \'Hello\'\n+ \' World\';')
+  });
+});

package/dist/render/htmlMonoTags.d.ts

@@ -0,0 +1,6 @@
+export declare const htmlMonoTags: {
+    link: boolean;
+    meta: boolean;
+    embed: boolean;
+};
+//# sourceMappingURL=htmlMonoTags.d.ts.map

package/dist/render/htmlMonoTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlMonoTags.d.ts","sourceRoot":"","sources":["../../src/render/htmlMonoTags.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;CAMxB,CAAA"}

package/dist/render/htmlMonoTags.js

@@ -0,0 +1,9 @@
+// HTML void tags must be single tags with no closing slash.
+// e.g. <meta whatever=""> not <meta whatever="" />
+export const htmlMonoTags = {
+  //script: true,
+  //style: true,
+  link: true,
+  meta: true,
+  embed: true
+};

package/dist/render/htmlNoSelfCloseTags.d.ts

@@ -0,0 +1,27 @@
+export declare const htmlNoSelfCloseTags: {
+    a: boolean;
+    article: boolean;
+    body: boolean;
+    blockquote: boolean;
+    button: boolean;
+    canvas: boolean;
+    caption: boolean;
+    code: boolean;
+    content: boolean;
+    dialog: boolean;
+    div: boolean;
+    fieldset: boolean;
+    figure: boolean;
+    footer: boolean;
+    header: boolean;
+    pre: boolean;
+    section: boolean;
+    select: boolean;
+    strong: boolean;
+    sub: boolean;
+    table: boolean;
+    tbody: boolean;
+    textarea: boolean;
+    video: boolean;
+};
+//# sourceMappingURL=htmlNoSelfCloseTags.d.ts.map

package/dist/render/htmlNoSelfCloseTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlNoSelfCloseTags.d.ts","sourceRoot":"","sources":["../../src/render/htmlNoSelfCloseTags.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAA"}

package/dist/render/htmlNoSelfCloseTags.js

@@ -0,0 +1,34 @@
+// These HTML elements must have a starting tag and ending tag
+// Otherwise they are treated as just an opening tag, and grab
+// everything afterwards
+// e.g. <textarea /> is invalid, and will break the layout
+// incomplete
+// there are so many, lets register the opposite instead
+export const htmlNoSelfCloseTags = {
+  a: true,
+  article: true,
+  body: true,
+  blockquote: true,
+  button: true,
+  canvas: true,
+  caption: true,
+  /// maybe not needed
+  code: true,
+  content: true,
+  dialog: true,
+  div: true,
+  fieldset: true,
+  figure: true,
+  footer: true,
+  header: true,
+  pre: true,
+  section: true,
+  select: true,
+  strong: true,
+  sub: true,
+  table: true,
+  tbody: true,
+  // not sure
+  textarea: true,
+  video: true
+};

package/dist/render/htmlSelfClosableTags.d.ts

@@ -0,0 +1,6 @@
+export declare const htmlSelfClosableTags: {
+    hr: boolean;
+    br: boolean;
+    img: boolean;
+};
+//# sourceMappingURL=htmlSelfClosableTags.d.ts.map

package/dist/render/htmlSelfClosableTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlSelfClosableTags.d.ts","sourceRoot":"","sources":["../../src/render/htmlSelfClosableTags.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB;;;;CAIhC,CAAA"}

package/dist/render/htmlSelfClosableTags.js

@@ -0,0 +1,7 @@
+// These HTML elements can self close like
+// <hr />
+export const htmlSelfClosableTags = {
+  hr: true,
+  br: true,
+  img: true
+};

package/dist/render/htmlSingleOnlyTags.d.ts

@@ -0,0 +1,8 @@
+export declare const htmlSingleTags: {
+    img: boolean;
+    input: boolean;
+    br: boolean;
+    hr: boolean;
+    meta: boolean;
+};
+//# sourceMappingURL=htmlSingleOnlyTags.d.ts.map

package/dist/render/htmlSingleOnlyTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlSingleOnlyTags.d.ts","sourceRoot":"","sources":["../../src/render/htmlSingleOnlyTags.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAA"}

package/dist/render/htmlSingleOnlyTags.js

@@ -0,0 +1,12 @@
+// HTML elements that can only have one tag, no separate closing tag
+// some cannot have / like <meta>
+// others like <hr> can be <hr />. I guess both are valid
+// list is not complete
+// source: https://blog.teamtreehouse.com/to-close-or-not-to-close-tags-in-html5#:~:text=There%20are%20also%20tags%20that,%2C%20hr%2C%20meta%2C%20etc.
+export const htmlSingleTags = {
+  img: true,
+  input: true,
+  br: true,
+  hr: true,
+  meta: true
+};

package/dist/render/htmlVoidTags.d.ts

@@ -0,0 +1,19 @@
+export declare const htmlVoidTags: {
+    area: boolean;
+    base: boolean;
+    br: boolean;
+    col: boolean;
+    command: boolean;
+    embed: boolean;
+    hr: boolean;
+    img: boolean;
+    input: boolean;
+    keygen: boolean;
+    link: boolean;
+    meta: boolean;
+    param: boolean;
+    source: boolean;
+    track: boolean;
+    wbr: boolean;
+};
+//# sourceMappingURL=htmlVoidTags.d.ts.map

package/dist/render/htmlVoidTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlVoidTags.d.ts","sourceRoot":"","sources":["../../src/render/htmlVoidTags.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAiBxB,CAAA"}

package/dist/render/htmlVoidTags.js

@@ -0,0 +1,37 @@
+// may not have children
+export const htmlVoidTags = {
+  area: true,
+  base: true,
+  br: true,
+  col: true,
+  command: true,
+  embed: true,
+  hr: true,
+  img: true,
+  input: true,
+  keygen: true,
+  link: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true
+};
+// export const htmlVoidTags = [
+// 'area',
+// 'base',
+// 'br',
+// 'col',
+// 'embed',
+// 'hr',
+// 'img',
+// 'input',
+// 'link',
+// 'meta',
+// 'param',
+// 'script', // missing from source list
+// 'source',
+// 'style', // missing from source list
+// 'track',
+// 'wbr',
+// ]

package/dist/render/instantiateClassComponent.d.ts

@@ -0,0 +1,5 @@
+import type { ContentNodeClassComponent } from '../ContentNode.js';
+import type { TungstenElement } from '../TungstenElement.js';
+import type { Instance } from '../Instance/Instance.js';
+export declare function instantiateClassComponent(node: ContentNodeClassComponent, parentComponent: (TungstenElement | null) | undefined, instance: Instance): Promise<import("../Components.jsx").TungstenBaseComponent<any, any>>;
+//# sourceMappingURL=instantiateClassComponent.d.ts.map

package/dist/render/instantiateClassComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instantiateClassComponent.d.ts","sourceRoot":"","sources":["../../src/render/instantiateClassComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAIvD,wBAAsB,yBAAyB,CAC3C,IAAI,EAAE,yBAAyB,EAAE,eAAe,GAAE,eAAe,GAAG,IAAI,aAAO,EAAE,QAAQ,EAAE,QAAQ,wEAetG"}

package/dist/render/instantiateClassComponent.js

@@ -0,0 +1,17 @@
+import { $props, $routeData, $routeParams, $type } from "../contentNodeSymbols.js";
+//import type { TungstenComponent, TungstenComponentProps } from '../TungstenComponent.jsx'
+export async function instantiateClassComponent(node, parentComponent = null, instance) {
+  const Component = node[$type];
+  const element = new Component({
+    props: node[$props],
+    routeParams: node[$routeParams],
+    routeData: node[$routeData],
+    instance,
+    parentElement: parentComponent
+  });
+  //console.log('init on', Component.name)
+  await element.__init();
+  //console.log('init done on', Component.name)
+  if (parentComponent !== null) parentComponent.childComponents.push(element); // register the child in the parent's list of child components
+  return element;
+}

package/dist/render/instantiateComponent.d.ts

@@ -0,0 +1,5 @@
+import type { AnyComponent } from '../AnyComponent.js';
+import { ContentNodeComponentAny } from '../ContentNode.js';
+import { Instance } from '../Instance/Instance.js';
+export declare function instantiateComponent(node: ContentNodeComponentAny, parentComponent: AnyComponent | null, instance: Instance): import("../FunctionComponentStandIn.js").FunctionElement<import("../ContentNode.js").NodeProps, unknown> | Promise<import("../Components.jsx").TungstenBaseComponent<any, any>>;
+//# sourceMappingURL=instantiateComponent.d.ts.map

package/dist/render/instantiateComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instantiateComponent.d.ts","sourceRoot":"","sources":["../../src/render/instantiateComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,uBAAuB,EAAwC,MAAM,mBAAmB,CAAA;AACjG,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAIlD,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,uBAAuB,EAAE,eAAe,EAAE,YAAY,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,mLAS1F"}

package/dist/render/instantiateComponent.js

@@ -0,0 +1,12 @@
+import { ContentNodeComponentIsClassComponent } from "../ContentNode.js";
+import { instantiateClassComponent } from "./instantiateClassComponent.js";
+import { instantiateFunctionComponent } from "./instantiateFunctionComponent.js";
+export function instantiateComponent(node, parentComponent, instance) {
+  if (ContentNodeComponentIsClassComponent(node)) {
+    const component = instantiateClassComponent(node, parentComponent, instance);
+    return component;
+  } else {
+    const componentStandIn = instantiateFunctionComponent(node, parentComponent, instance);
+    return componentStandIn;
+  }
+}

package/dist/render/instantiateFunctionComponent.d.ts

@@ -0,0 +1,6 @@
+import type { ContentNodeFunctionComponent } from '../ContentNode.js';
+import type { AnyComponent } from '../AnyComponent.js';
+import type { Instance } from '../Instance/Instance.js';
+import { FunctionElement } from '../FunctionComponentStandIn.js';
+export declare function instantiateFunctionComponent(node: ContentNodeFunctionComponent, parentComponent: AnyComponent | null, instance: Instance): FunctionElement<import("../ContentNode.js").NodeProps, unknown>;
+//# sourceMappingURL=instantiateFunctionComponent.d.ts.map

package/dist/render/instantiateFunctionComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instantiateFunctionComponent.d.ts","sourceRoot":"","sources":["../../src/render/instantiateFunctionComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAGhE,wBAAgB,4BAA4B,CACxC,IAAI,EAAE,4BAA4B,EAClC,eAAe,EAAE,YAAY,GAAG,IAAI,EACpC,QAAQ,EAAE,QAAQ,mEAKrB"}

package/dist/render/instantiateFunctionComponent.js

@@ -0,0 +1,7 @@
+import { FunctionElement } from "../FunctionComponentStandIn.js";
+import { $props, $routeData, $routeParams, $type } from "../contentNodeSymbols.js";
+export function instantiateFunctionComponent(node, parentComponent, instance) {
+  const componentStandIn = new FunctionElement(node[$type], node[$props], node[$routeParams], node[$routeData], instance, parentComponent);
+  if (parentComponent !== null) parentComponent.childComponents.push(componentStandIn);
+  return componentStandIn;
+}

package/dist/render/printComponentNameInSource.d.ts

@@ -0,0 +1,2 @@
+export declare const printComponentNamesInSource: boolean;
+//# sourceMappingURL=printComponentNameInSource.d.ts.map

package/dist/render/printComponentNameInSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printComponentNameInSource.d.ts","sourceRoot":"","sources":["../../src/render/printComponentNameInSource.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2BAA2B,SAAQ,CAAA"}

package/dist/render/printComponentNameInSource.js

@@ -0,0 +1,2 @@
+import { isDev } from "../isDev.js";
+export const printComponentNamesInSource = isDev;

package/dist/render/processBody.d.ts

@@ -0,0 +1,4 @@
+import { RenderingNodeElement } from '../RenderingNode.js';
+import { HeadData } from './HeadData.js';
+export declare function processBody(bodyNode: RenderingNodeElement, headData: HeadData): void;
+//# sourceMappingURL=processBody.d.ts.map

package/dist/render/processBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processBody.d.ts","sourceRoot":"","sources":["../../src/render/processBody.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAqB,MAAM,qBAAqB,CAAA;AAG7E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAIxC,wBAAgB,WAAW,CACvB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,QAAQ,QAuErB"}

package/dist/render/processBody.js

@@ -0,0 +1,67 @@
+import { existsSync } from 'fs';
+import { $props, $type } from "../contentNodeSymbols.js";
+import { clientFolder } from "../settings.js";
+import serializeJavascript from 'serialize-javascript';
+import { join } from 'path';
+export function processBody(bodyNode, headData) {
+  const {
+    instance,
+    dev
+  } = headData;
+  if (bodyNode[$props].children === undefined) bodyNode[$props].children = [];else if (!Array.isArray(bodyNode[$props].children)) bodyNode[$props].children = [bodyNode[$props].children];
+  // entry script
+  const scriptNode = {
+    [$type]: 'script',
+    [$props]: {
+      'data--t-internal': undefined,
+      src: dev ? `/${clientFolder}/client.js` : `/bundle/clientWithEnv.js`
+    }
+  };
+  if (dev) scriptNode[$props].type = 'module';else scriptNode[$props].defer = true;
+  bodyNode[$props].children.unshift(scriptNode);
+  if (dev) {
+    if (existsSync(join(headData.compilationLocation, clientFolder, '.public.env.js'))) {
+      // env file
+      const envScriptNode = {
+        [$type]: 'script',
+        [$props]: {
+          'data--t-internal': undefined,
+          type: 'module',
+          src: `/${clientFolder}/.public.env.js`
+        }
+      };
+      bodyNode[$props].children.unshift(envScriptNode);
+    }
+    // cjs loading helpers
+    const cjsHelpersScriptNode = {
+      [$type]: 'script',
+      [$props]: {
+        'data--t-internal': undefined,
+        type: 'module',
+        src: `/${clientFolder}/cjsHelpers.js`
+      }
+    };
+    bodyNode[$props].children.unshift(cjsHelpersScriptNode);
+  }
+  const {
+    content: _,
+    ...networkMatchedRoundInfo
+  } = instance.matchedRouteInfo; // @typescript-eslint/no-unused-vars
+  let varsScriptContent = `var __tungsten_prod__=${String(dev)};` + `var __tungsten_global_data__=${serializeJavascript(instance.globalData)};` + `var __tungsten_matched_route_info__=${serializeJavascript(networkMatchedRoundInfo)};`;
+  // route Data
+  if (instance.routeData !== undefined) {
+    varsScriptContent += `var __tungsten_route_data__=${serializeJavascript(instance.routeData)};`;
+  }
+  // router data
+  // if (instance.routerData !== undefined) {
+  //     varsScriptContent += `var __tungsten_router_data__=${serializeJavascript(instance.routerData)};`
+  // }
+  const varsScriptNode = {
+    [$type]: 'script',
+    [$props]: {
+      'data--t-internal': undefined,
+      children: varsScriptContent
+    }
+  };
+  bodyNode[$props].children.unshift(varsScriptNode);
+}

package/dist/render/processHead.d.ts

@@ -0,0 +1,4 @@
+import type { HeadData } from './HeadData.js';
+import { RenderingNodeElement } from '../RenderingNode.js';
+export declare function processHead(headNode: RenderingNodeElement, headData: HeadData): void;
+//# sourceMappingURL=processHead.d.ts.map

package/dist/render/processHead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processHead.d.ts","sourceRoot":"","sources":["../../src/render/processHead.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAK7C,OAAO,EAAE,oBAAoB,EAAqB,MAAM,qBAAqB,CAAA;AAO7E,wBAAgB,WAAW,CACvB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,QAAQ,QAoGrB"}

package/dist/render/processHead.js

@@ -0,0 +1,96 @@
+import serializeJavascript from 'serialize-javascript';
+import { clientFolder, componentCssFolder, componentCssFile } from "../settings.js";
+import { addImportMap } from "./addImportMap.js";
+import { $props, $type } from "../contentNodeSymbols.js";
+import { windowGlobalEnvStatement } from 'tungsten/env/windowGlobalEnvStatement.js';
+// process the tree returned by the root component
+// doing things like ensuring there is are html and head elements,
+// and adding necessary style and script tags
+export function processHead(headNode, headData) {
+  const {
+    instance,
+    importAliases,
+    clientImportAliases,
+    dev,
+    siteBasePath
+  } = headData;
+  //console.log('processing head. dev is', dev)
+  if (headNode[$props].children === undefined) headNode[$props].children = [];else if (!Array.isArray(headNode[$props].children)) headNode[$props].children = [headNode[$props].children];
+  headNode[$props].children.unshift({
+    [$type]: 'link',
+    [$props]: {
+      'data--t-internal': undefined,
+      'data--t-persist': true,
+      rel: 'stylesheet',
+      href: `${siteBasePath}/${componentCssFolder}/${componentCssFile}`
+    }
+  });
+  // entry script
+  const scriptNode = {
+    [$type]: 'script',
+    [$props]: {
+      'data--t-internal': undefined,
+      src: dev ? `/${clientFolder}/client.js` : `${siteBasePath}/bundle/clientWithEnv.js`
+    }
+  };
+  if (dev) scriptNode[$props].type = 'module';else scriptNode[$props].defer = true;
+  headNode[$props].children.unshift(scriptNode);
+  // public env
+  if (dev) {
+    if (headData.tungstenPublicEnv !== undefined) {
+      const envScriptNode = {
+        [$type]: 'script',
+        [$props]: {
+          'data--t-internal': undefined,
+          children: windowGlobalEnvStatement('tungstenPublicEnv', headData.tungstenPublicEnv)
+        }
+      };
+      headNode[$props].children.unshift(envScriptNode);
+    }
+  }
+  if (dev) {
+    // cjs loading helpers
+    const cjsHelpersScriptNode = {
+      [$type]: 'script',
+      [$props]: {
+        'data--t-internal': undefined,
+        src: `${siteBasePath}/${clientFolder}/cjsHelpers.js`
+      }
+    };
+    cjsHelpersScriptNode[$props].type = 'module';
+    headNode[$props].children.unshift(cjsHelpersScriptNode);
+  }
+  const {
+    content: _,
+    ...networkMatchedRoundInfo
+  } = instance.matchedRouteInfo; // @typescript-eslint/no-unused-vars
+  let varsScriptContent = `var __tungsten_prod__=${String(!dev)};` + `var __tungsten_global_data__=${serializeJavascript(instance.globalData)};` + `var __tungsten_matched_route_info__=${serializeJavascript(networkMatchedRoundInfo)};`;
+  // route Data
+  if (instance.routeData !== undefined) {
+    varsScriptContent += `var __tungsten_route_data__=${serializeJavascript(instance.routeData)};`;
+  }
+  // // router data
+  // if (instance.routerData !== undefined) {
+  //     varsScriptContent += `var __tungsten_router_data__=${serializeJavascript(instance.routerData)};`
+  // }
+  const varsScriptNode = {
+    [$type]: 'script',
+    [$props]: {
+      children: varsScriptContent
+    }
+  };
+  headNode[$props].children.unshift(varsScriptNode);
+  const contentTypeMetaNode = {
+    [$type]: 'meta',
+    [$props]: {
+      'data--t-internal': undefined,
+      'data--t-persist': true,
+      'http-equiv': 'Content-Type',
+      content: 'text/html; charset=utf-8'
+    }
+  };
+  headNode[$props].children.unshift(contentTypeMetaNode);
+  // we get in here and shift any elements marked with a "before" prop to the top,
+  // to let them run before others
+  if (dev) addImportMap(headNode, importAliases, clientImportAliases);
+}

package/dist/render/processHtmlNode.d.ts

@@ -0,0 +1,3 @@
+import type { ContentNodeHtml } from '../ContentNode.js';
+export declare function processHtmlNode(node: ContentNodeHtml): void;
+//# sourceMappingURL=processHtmlNode.d.ts.map

package/dist/render/processHtmlNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processHtmlNode.d.ts","sourceRoot":"","sources":["../../src/render/processHtmlNode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxD,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,QAcpD"}

package/dist/render/processHtmlNode.js

@@ -0,0 +1,16 @@
+import { $props, $type } from "../contentNodeSymbols.js";
+export function processHtmlNode(node) {
+  // if (node[$type] === 'button') {
+  //     console.log('processing html node', node)
+  //     console.log('type', node[$type])
+  //     console.log('prop type', node[$props].type)
+  //     console.log('type cond', node[$type] === 'button')
+  //     console.log('prop type cond', !node[$props].type)
+  // }
+  // set a button without specified type to button, so buttons don't submit forms unless instructed to
+  if (node[$type] === 'button' && !node[$props].type) {
+    //if (node[$type] === 'button') console.log('setting button type to button')
+    node[$props].type = 'button';
+  }
+  //if (node[$type] === 'button')  console.log('res', node)
+}

package/dist/render/processProps.d.ts

@@ -0,0 +1,3 @@
+import { TungstenComponentGenericProps } from '../Components.jsx';
+export declare function processProps(props: TungstenComponentGenericProps): TungstenComponentGenericProps;
+//# sourceMappingURL=processProps.d.ts.map

package/dist/render/processProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processProps.d.ts","sourceRoot":"","sources":["../../src/render/processProps.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAA;AAuBjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,6BAA6B,iCA2ChE"}