tungsten 0.1.6 → 0.1.24

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

@@ -0,0 +1 @@
+{"version":3,"file":"componentNodeToRenderingToTree.d.ts","sourceRoot":"","sources":["../../src/render/componentNodeToRenderingToTree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,EAAwC,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAGnG,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGjD,wBAAsB,8BAA8B,CAAC,aAAa,EAAE,oBAAoB,EAAE,eAAe,EAAE,YAAY,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAWtM"}

package/dist/render/componentNodeToRenderingToTree.js

@@ -0,0 +1,15 @@
+import { ContentNodeComponentIsClassComponent } from "../ContentNode.js";
+import { classComponentNodeToRenderingTree } from "./classComponentNodeToRenderingTree.js";
+import { functionComponentNodeToRenderingTree } from "./functionComponentNodeToRenderingTree.js";
+import { TungstenError } from "../TungstenError.js";
+export async function componentNodeToRenderingToTree(componentNode, parentComponent, instance, noEscape) {
+  //console.log('componentRenderToTree component', component)
+  if (ContentNodeComponentIsClassComponent(componentNode)) {
+    //console.log('class component')
+    return await classComponentNodeToRenderingTree(componentNode, parentComponent, instance, noEscape);
+  } else {
+    //console.log('function component')
+    return await functionComponentNodeToRenderingTree(componentNode, parentComponent, instance, noEscape);
+  }
+  throw new TungstenError(`Error, component passed to componentRenderToTree() was not a valid component`);
+}

package/dist/render/componentNodeToTree.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"componentNodeToTree.d.ts","sourceRoot":"","sources":["../../src/render/componentNodeToTree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAwC,KAAK,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAOtG,wBAAsB,4BAA4B,CAAC,IAAI,EAAE,uBAAuB,EAAE,eAAe,EAAE,YAAY,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,iEAS5J"}

package/dist/render/componentNodeToTree.js

@@ -0,0 +1,16 @@
+import { ContentNodeComponentIsClassComponent } from "../ContentNode.js";
+import { classComponentNodeToRenderingTree } from "./classComponentNodeToRenderingTree.js";
+import { functionComponentNodeToRenderingTree } from "./functionComponentNodeToRenderingTree.js";
+// we have instantiation in two places
+// here, and instantiate component
+// lets simplify
+export async function componentNodeToRenderingTree(node, parentComponent, instance, noEscape) {
+  if (ContentNodeComponentIsClassComponent(node)) {
+    return await classComponentNodeToRenderingTree(node, parentComponent, instance, noEscape);
+    // if (parentComponent) add to children
+  } else {
+    //const elementStandIn = instantiateFunctionComponent(node, parentComponent, instance)
+    return await functionComponentNodeToRenderingTree(node, parentComponent, instance, noEscape);
+    // if (parentComponent) add to children
+  }
+}

package/dist/render/contentTreeToRenderingTree.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentTreeToRenderingTree.d.ts","sourceRoot":"","sources":["../../src/render/contentTreeToRenderingTree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EACH,KAAK,WAAW,EACnB,MAAM,mBAAmB,CAAA;AAU1B,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,GACzI,OAAO,CAAC,aAAa,CAAC,CAuE3B"}

package/dist/render/contentTreeToRenderingTree.js

@@ -0,0 +1,69 @@
+import { ContentNodeIsLiteral, ContentNodeElementIsComponent, ContentNodeElementIsHtml, ContentNodeComponentIsClassComponent } from "../ContentNode.js";
+import { validChildren } from "../validChildren.js";
+import { debug } from "./debug.js";
+import { throwError } from "../throwError.js";
+import { $key, $props, $type } from "../contentNodeSymbols.js";
+import { classComponentNodeToRenderingTree } from "./classComponentNodeToRenderingTree.js";
+import { functionComponentNodeToRenderingTree } from "./functionComponentNodeToRenderingTree.js";
+import { processHtmlNode } from "./processHtmlNode.js";
+export async function contentTreeToRenderingTree(node, parentComponent, instance, noEscape) {
+  //console.log('completeTree node', node)
+  debug('completeTree node', node);
+  //console.log('contentTreeToRenderingTree tree', node)
+  if (node === undefined || node === null || node === false || node === true) {
+    // null / non-existent node
+    return node;
+  }
+  if (Array.isArray(node)) {
+    const nodes = [];
+    for (const i in node) {
+      const subNode = node[i];
+      nodes[i] = await contentTreeToRenderingTree(subNode, parentComponent, instance, noEscape);
+    }
+    return nodes;
+  }
+  node;
+  if (ContentNodeIsLiteral(node)) {
+    return node.toString();
+  }
+  debug('typeof type', typeof node[$type]);
+  if (ContentNodeElementIsHtml(node)) {
+    processHtmlNode(node);
+    debug('validChildren(children)', validChildren(node[$props].children));
+    const {
+      children,
+      ...rest
+    } = node[$props];
+    if (validChildren(children)) {
+      debug('children', node[$props].children);
+      const noEscape = node[$type] === 'script' || node[$type] === 'style' || '__noEscape' in node[$props] && node[$props].__noEscape !== false;
+      //console.log(node[$type], node[$props], 'noEscape', noEscape)
+      return {
+        [$type]: node[$type],
+        [$key]: node[$key],
+        [$props]: {
+          ...rest,
+          children: await contentTreeToRenderingTree(node[$props].children, parentComponent, instance, noEscape)
+        }
+      };
+    } else {
+      return {
+        [$type]: node[$type],
+        [$key]: node[$key],
+        [$props]: {
+          ...rest
+        }
+      };
+    }
+    //renderingNode node
+  }
+  if (ContentNodeElementIsComponent(node)) {
+    if (ContentNodeComponentIsClassComponent(node)) {
+      return classComponentNodeToRenderingTree(node, parentComponent, instance, noEscape);
+    } else {
+      return functionComponentNodeToRenderingTree(node, parentComponent, instance, noEscape);
+    }
+  }
+  const n = node; // eslint-disable-line @typescript-eslint/no-unused-vars
+  throwError('render -> completeTree()', `node returned from a component did not match expected format.` + ` Node: ${JSON.stringify(node)}`);
+}

package/dist/render/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function debug(...texts: unknown[]): void;
+//# sourceMappingURL=debug.d.ts.map

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,EAAsE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAGrI,OAAO,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA;AAGhE,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,13 @@
+import { makeRenderingNodeFunctionComponentFromContentNodeFunctionComponent } from "../RenderingNode.js";
+import { getStyledContentFromFunctionComponent } from "../getStyledContentFromFunctionComponent.js";
+import { contentTreeToRenderingTree } from "./contentTreeToRenderingTree.js";
+import { instantiateFunctionComponent } from "./instantiateFunctionComponent.js";
+export async function functionComponentNodeToRenderingTree(contentNode, parentComponent, instance, noEscape) {
+  const standIn = instantiateFunctionComponent(contentNode, parentComponent, instance);
+  //console.log('functionComponentToTree')
+  // MC? setCurrentComponent(standIn)
+  const content = await getStyledContentFromFunctionComponent(standIn);
+  //const content = await getStyledContentFromFunctionComponent(standIn.func, standIn.props)
+  // MC? 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 'tungsten/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 { ComponentInstance } from '../ComponentInstance.js';
+import type { Instance } from '../Instance/Instance.js';
+export declare function instantiateClassComponent(node: ContentNodeClassComponent, parentComponent: (ComponentInstance | 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,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAIvD,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,yBAAyB,EAAE,eAAe,GAAE,iBAAiB,GAAG,IAAI,aAAO,EAAE,QAAQ,EAAE,QAAQ,wEAcpJ"}

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,
+    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,CAAC,IAAI,EAAE,uBAAuB,EAAE,eAAe,EAAE,YAAY,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,mLAQ3H"}

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;AAS7E,wBAAgB,WAAW,CACvB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,QAAQ,QAkGrB"}