tungsten 0.3.3 → 0.3.4

package/dist/update/integrateUpdateVdom.js

@@ -24,6 +24,57 @@ import { clearCurrentComponent } from 'tungsten/hooks/clearCurrentComponent.js';
 import { isDev } from "../isDev.js";
 import { $original } from "../componentProxyHandlers.js";
 import { booleanAttributeValue } from "../booleanAttributeValue.js";
+import { propsAreEqual } from "../propsAreEqual.js";
+import { markRendered, refreshTracing, renderedAt, trace, tracing } from "../stateTracking.js";
+import { beginMountScope, discardPendingMounts, endMountScope, queueMount } from "./pendingMounts.js";
+/**
+ * How many dom nodes each element's rendered content currently occupies, recorded on
+ * every real update. When an update is skipped for unchanged props the child's dom is
+ * untouched, so the count still holds -- and the dom pointer can be advanced without
+ * measuring the region, which would mean scanning parent.childNodes.
+ */
+const skippedNodesLength = new WeakMap();
+const reconcileStats = new Map();
+let reconcileDepth = 0;
+function bucket(name) {
+  const existing = reconcileStats.get(name);
+  if (existing !== undefined) return existing;
+  const created = {
+    n: 0,
+    ms: 0
+  };
+  reconcileStats.set(name, created);
+  return created;
+}
+/** times `work` into `name` when tracing, and is a plain call-through when not */
+async function timed(name, work) {
+  if (!tracing()) return work();
+  const b = bucket(name);
+  const start = performance.now();
+  try {
+    return await work();
+  } finally {
+    b.n++;
+    b.ms += performance.now() - start;
+  }
+}
+function timedSync(name, work) {
+  if (!tracing()) return work();
+  const b = bucket(name);
+  const start = performance.now();
+  try {
+    return work();
+  } finally {
+    b.n++;
+    b.ms += performance.now() - start;
+  }
+}
+function reportReconcileStats(elementName) {
+  if (reconcileStats.size === 0) return;
+  const parts = [...reconcileStats.entries()].sort(([, a], [, b]) => b.ms - a.ms).map(([name, b]) => `${name} ${b.ms.toFixed(1)}ms/${b.n}`);
+  trace('RECONCILE', elementName, parts.join('  '));
+  reconcileStats.clear();
+}
 function debug(...texts) {
   //console.log(...texts)
   //console.log(getStackTrace().split('\n')[2])
@@ -33,6 +84,15 @@ const timing = false; // eslint-disable-line no-type-assertion/no-type-assertion
 export async function integrateElementUpdateVdom(element, newContent) {
   let startTime = 0;
   if (timing) startTime = new Date().getMilliseconds();
+  // Only the outermost call reports, so nested components roll up into one line per
+  // update rather than one per component. Depth is restored from the value captured on
+  // entry rather than decremented, so a throw in a nested call cannot leave the counter
+  // stuck above zero and silently suppress every later report.
+  const reconcileEntryDepth = ++reconcileDepth;
+  if (reconcileEntryDepth === 1) refreshTracing();
+  // anything created during this update mounts detached and is attached before the
+  // outermost integrate returns, so its mount hooks wait until then
+  beginMountScope();
   debug(`integrateElementUpdateVdom`, element);
   debug(`integrateElementUpdateVdom`, newContent);
   //console.log('***** integrateElementUpdateVdom', element.constructor.name, '*****')
@@ -97,11 +157,17 @@ export async function integrateElementUpdateVdom(element, newContent) {
   //console.log('firstElement', element.__domRegion?.firstElement)
   //console.log('lastElement', element.__domRegion?.lastElement)
   //console.log('Current Content after update for element', element.constructor.name, 'is', element.__currentContent)
-  const newPositionOfFirstElement = domRegion.positionOfFirst();
-  const newPositionOfLastElement = domRegion.positionOfLast();
+  // These were just written by updateByIndexes() immediately above, so the region's
+  // bounds are already known -- asking positionOfFirst()/positionOfLast() would
+  // indexOf them back out of parent.childNodes, an O(n) scan per component update.
+  const newPositionOfFirstElement = previousPositionOfFirstElement;
+  const newPositionOfLastElement = domPointer.index - 1;
   const newNodesLength = newPositionOfFirstElement >= 0 ? 1 + newPositionOfLastElement - newPositionOfFirstElement : 0;
   //console.log('finished updating element. ', element.constructor.name, ' El positions:', newPositionOfFirstElement, newPositionOfLastElement)
   if (timing) out(`Updated ${element.constructor.name} in ${new Date().getMilliseconds() - startTime}ms`);
+  reconcileDepth = reconcileEntryDepth - 1;
+  if (reconcileDepth === 0 && tracing()) reportReconcileStats(element.constructor.name);
+  endMountScope();
   // newNodesLength previousNodesLength
   return {
     renderedContent: renderedTree,
@@ -149,7 +215,7 @@ export async function applyUpdate({
       //oldNode
       //console.log('array update', newNode)
       //console.log('old array', oldNode)
-      const keyedOldChildren = getKeyedOldChildren(oldNode);
+      const keyedOldChildren = timedSync('indexOldKeys', () => getKeyedOldChildren(oldNode));
       const tempOldChildren = [...oldNode];
       if (Object.keys(keyedOldChildren).length > 0) {
         //console.log('handling a keyed array')
@@ -198,7 +264,7 @@ export async function applyUpdate({
             // create a throwaway DomPointer because we are going to manage our DomPointer differently
             const tempDomPointer = new DomPointer(domPointer.parent, domPointer.index);
             // update
-            renderedContent = await applyUpdate({
+            const updated = await timed('keyedUpdate', () => applyUpdate({
               tungstenElement,
               instance,
               newNode: childNode,
@@ -206,10 +272,11 @@ export async function applyUpdate({
               domRegion,
               domPointer: tempDomPointer,
               parentNode
-            });
+            }));
+            renderedContent = updated;
             // move
             //console.log('moving the keyed item', childNode[$key])
-            moveRenderedContent(renderedContent, domPointer);
+            timedSync('keyedMove', () => moveRenderedContent(updated, domPointer));
             // delete oldChild from temp list
             delete tempOldChildren[oldChildIndex];
           } else {
@@ -221,7 +288,7 @@ export async function applyUpdate({
               //console.log('update/replace a non keyed item', _nki)
               //throwError('b', 'b')
               // update/replace as required
-              renderedContent = await applyUpdate({
+              const updated = await timed('unkeyedUpdate', () => applyUpdate({
                 tungstenElement,
                 instance,
                 newNode: childNode,
@@ -229,11 +296,12 @@ export async function applyUpdate({
                 domRegion,
                 domPointer: tempDomPointer,
                 parentNode
-              });
+              }));
+              renderedContent = updated;
               // move -- we need to move it, because we may have removed or inserted elements
               // pushing the original out of place
               //console.log('moving the non keyed item', _nki)
-              moveRenderedContent(renderedContent, domPointer);
+              timedSync('unkeyedMove', () => moveRenderedContent(updated, domPointer));
               // remove replaced node from list
               delete tempOldChildren[i];
             } else {
@@ -241,13 +309,13 @@ export async function applyUpdate({
               //console.log('dp', domPointer)
               //throwError('c', 'c')
               // create
-              renderedContent = await createNode({
+              renderedContent = await timed('create', () => createNode({
                 tungstenElement,
                 instance,
                 newNode: childNode,
                 domPointer,
                 parentNode
-              });
+              }));
             }
           }
           renderedNodes.push(renderedContent);
@@ -258,7 +326,7 @@ export async function applyUpdate({
         for (const oldChild of tempOldChildren) {
           if (oldChild) {
             //console.log('deleting old child', oldChild)
-            deleteNodeIfRendered(oldChild);
+            timedSync('trim', () => deleteNodeIfRendered(oldChild));
           }
         }
         return renderedNodes;
@@ -490,17 +558,26 @@ function moveRenderedContent(renderedContent, domPointer) {
 }
 function moveDomNode(domNode, domPointer) {
   //console.log('moving domNode', domNode)
-  if (domPointer.positionOf(domNode) !== domPointer.index) {
+  // O(1) position check. positionOf() is Array.indexOf over parent.childNodes, which
+  // is O(n) in the sibling count -- and this runs once per node per update, making a
+  // keyed array update O(n^2): 20k rows cost ~400M comparisons even when nothing moved.
+  // Reading the node already at `index` answers the same question, and differs from
+  // domNode in exactly the cases indexOf(domNode) !== index did: the node is elsewhere,
+  // is not a child at all (indexOf -1), or index is past the end (undefined).
+  // one live-NodeList read, reused as the insertBefore reference below -- see
+  // DomPointer.insert() for why these reads are worth counting
+  const reference = domPointer.parent.childNodes[domPointer.index]; // eslint-disable-line no-type-assertion/no-type-assertion -- indexing past the end gives undefined, which the DOM types do not model
+  if (reference !== domNode) {
     //console.log('document.activeElement', document.activeElement, domNode ==  document.activeElement,  domNode ===  document.activeElement)
     const ownerDocument = domNode.ownerDocument;
     const hasFocus = domNode === ownerDocument.activeElement;
     const activeElement = ownerDocument.activeElement;
-    if (domPointer.index >= domPointer.parent.childNodes.length) {
+    if (reference === undefined) {
       //console.log('appending', domNode)
       domPointer.parent.appendChild(domNode);
     } else {
       //console.log('inserting at', domPointer.index, domNode)
-      domPointer.parent.insertBefore(domNode, domPointer.parent.childNodes[domPointer.index]);
+      domPointer.parent.insertBefore(domNode, reference);
     }
     //console.log('had focus', hasFocus)
     if (hasFocus) domNode.focus();
@@ -598,12 +675,7 @@ function createComment({
   debug('-createComment');
   //console.log('createComment', text)
   const comment = documentFromParent(domPointer.parent).createComment(text);
-  if (domPointer.index >= domPointer.parent.childNodes.length) {
-    domPointer.parent.appendChild(comment);
-  } else {
-    domPointer.parent.insertBefore(comment, domPointer.parent.childNodes[domPointer.index]);
-  }
-  domPointer.increment();
+  domPointer.insert(comment);
   return comment;
 }
 export function processHtmlNode(node, parentNode) {
@@ -744,15 +816,10 @@ function createLiteral(value, domPointer) {
   debug('-createLiteral:', value);
   //const textNode = createTextElement(String(value), domPointer)
   const text = String(value);
-  debug('dom parent', domPointer.parent);
-  debug('dom index', domPointer.index);
+  if (isDev) debug('dom parent', domPointer.parent);
+  if (isDev) debug('dom index', domPointer.index);
   const textNode = documentFromParent(domPointer.parent).createTextNode(text);
-  if (domPointer.parent.childNodes.length === domPointer.index) {
-    domPointer.parent.appendChild(textNode);
-  } else {
-    domPointer.parent.insertBefore(textNode, domPointer.parent.childNodes[domPointer.index]);
-  }
-  domPointer.increment();
+  domPointer.insert(textNode);
   //domPointer.increment()
   return typeof value === 'string' ? {
     [$type]: $string,
@@ -772,7 +839,8 @@ async function createHtmlElement(tungstenElement, instance, node, domPointer, pa
   processHtmlNode(node, parentNode);
   debug('-createHtmlElement', node);
   const htmlEl = documentFromParent(domPointer.parent).createElement(node[$type]);
-  addAttributes(tungstenElement, instance, node, htmlEl);
+  const extendableEl = htmlEl; // eslint-disable-line no-type-assertion/no-type-assertion -- attributes are attached to the element later
+  addAttributes(tungstenElement, instance, node, extendableEl);
   if (node[$type] === 'head') {
     for (const el of instance.persistentHeadChildren) {
       htmlEl.appendChild(el.cloneNode(true));
@@ -783,21 +851,19 @@ async function createHtmlElement(tungstenElement, instance, node, domPointer, pa
   if ('ref' in node[$props]) {
     node[$props].ref.current = htmlEl;
   }
-  debug('dom parent', domPointer.parent);
-  debug('dom parent children length', domPointer.parent.childNodes.length);
-  debug('domPointer.index', domPointer.index);
-  if (domPointer.index >= domPointer.parent.childNodes.length) {
-    domPointer.parent.appendChild(htmlEl);
-  } else {
-    debug('new html el', htmlEl);
-    debug('insert before', domPointer.parent.childNodes[domPointer.index]);
-    domPointer.parent.insertBefore(htmlEl, domPointer.parent.childNodes[domPointer.index]);
-    debug('created el', domPointer.get());
-  }
-  domPointer.increment();
+  // debug() has a commented-out body, but its arguments are still evaluated -- and these
+  // ones read the live NodeList, which walks the child list. Behind `if (isDev)` they
+  // short-circuit in dev and are removed from the production bundle entirely.
+  if (isDev) debug('dom parent', domPointer.parent);
+  if (isDev) debug('dom parent children length', domPointer.parent.childNodes.length);
+  if (isDev) debug('domPointer.index', domPointer.index);
+  if (isDev) debug('new html el', htmlEl);
   //!!!! node.domElement = el
   if (IsHTMLElement(domPointer.parent)) debug('***', node[$type], 'html created', htmlEl);
-  // children
+  // children -- built while htmlEl is still detached, then the finished subtree is
+  // inserted once below. Appending into an element that is already in the document
+  // makes the browser invalidate style and layout on every child; off document it
+  // does none of that until the subtree lands.
   const innerHtml = innerHtmlFromProps(node[$type], node[$props], validChildren(node[$props].children));
   let renderedChildren;
   if (innerHtml !== null) {
@@ -819,6 +885,8 @@ async function createHtmlElement(tungstenElement, instance, node, domPointer, pa
       htmlEl.value = String(node[$props].value);
     }
   }
+  // the subtree is complete, so attach it in one operation
+  domPointer.insert(htmlEl);
   return {
     ...node,
     domNode: htmlEl,
@@ -1039,6 +1107,7 @@ export async function createTungstenRootComponent(RootComponent, props, routePar
     instance,
     parentElement: null
   });
+  beginMountScope();
   try {
     await component.__init();
     const content = await component.__initialContent();
@@ -1060,13 +1129,16 @@ export async function createTungstenRootComponent(RootComponent, props, routePar
     });
     component.__domRegion = new DomRegion(container, domStartIndex, domPointer.index - domStartIndex);
     component.__currentContent = renderedContent;
-    component.__didMount();
+    queueMount(() => component.__didMount());
+    // everything this root created is attached by now, so the queued hooks can run
+    endMountScope();
     return {
       component,
       openingComment,
       closingComment
     };
   } catch (error) {
+    discardPendingMounts();
     component.__delete();
     while (container.childNodes.length > domStartIndex) {
       container.removeChild(container.childNodes[domStartIndex]);
@@ -1141,7 +1213,7 @@ async function createTungstenClassComponent(parent, instance, node, domPointer)
   debug(`[${c}]`, '&& dom region last element', element.__domRegion.lastElement);
   //console.log('created dom region', element.__domRegion)
   element.__currentContent = renderedContent;
-  element.__didMount();
+  queueMount(() => element.__didMount());
   const wrapper = {
     ...node,
     element,
@@ -1185,11 +1257,14 @@ async function createTungstenFunctionComponent(parent, instance, node, domPointe
   });
   //const renderedContent: RenderedContentNode = await integrateNode({ node: content, domRegion: null, domPointer, parent: element, instance })
   const domLength = domPointer.index - domStartIndex;
-  debug(`[${x}]`, '&& Continuing create FC', node);
-  debug(`[${x}]`, '&& domPointer.parent', domPointer.parent);
-  debug(`[${x}]`, '&& dom start index', domStartIndex);
-  debug(`[${x}]`, '&& dom length', domLength);
-  debug(`[${x}]`, '&& dom pointer children', domPointer.parent.childNodes);
+  if (isDev) {
+    // these run once per created component, and each allocates a template literal
+    debug(`[${x}]`, '&& Continuing create FC', node);
+    debug(`[${x}]`, '&& domPointer.parent', domPointer.parent);
+    debug(`[${x}]`, '&& dom start index', domStartIndex);
+    debug(`[${x}]`, '&& dom length', domLength);
+    debug(`[${x}]`, '&& dom pointer children', domPointer.parent.childNodes);
+  }
   //console.log('new dom region when creating func comp', node[$type].name, domPointer.parent)
   element.__domRegion = new DomRegion(domPointer.parent, domStartIndex, domLength);
   //console.log('&& dom region first element', element.__domRegion.firstElement)
@@ -1211,6 +1286,27 @@ async function updateClassComponent({
 }) {
   //console.log('-updateClassComponent', newNode)
   const element = oldNode.element;
+  // element.props still holds what was last rendered, so this asks "has anything
+  // changed since we last rendered?". If not, the child's dom is already correct and
+  // re-rendering it is wasted work -- which for a large list child means reconciling
+  // every row so an unrelated sibling can update. componentDidUpdate deliberately does
+  // not fire: the component did not update.
+  if (propsAreEqual(element.props, newNode[$props], renderedAt(element))) {
+    if (tracing()) trace('SKIP', element.constructor.name, '(props unchanged since tick', renderedAt(element), ')');
+    // the dom is current for these props, so the baseline moves with it -- otherwise a
+    // component that only ever skips keeps comparing against its mount tick, and the
+    // first shared object it is handed always looks changed
+    markRendered(element);
+    // the weakmap is only written by a previous update, so on the first update after
+    // mount fall back to measuring the element's own region -- its index caches were
+    // seeded when it was created, so this is not a scan either
+    const cachedLength = skippedNodesLength.get(element) ?? element.__domRegion?.length();
+    if (cachedLength !== undefined) {
+      domPointer.increment(cachedLength);
+      return oldNode;
+    }
+  }
+  if (tracing()) trace('RENDER', element.constructor.name, '(since tick', renderedAt(element), ')');
   element.props = newNode[$props];
   debug('update class component', newNode);
   //console.log('update class component', newNode)
@@ -1219,6 +1315,8 @@ async function updateClassComponent({
   //console.log('domPointer children', [...domPointer.parent.childNodes])
   //throwError('','')
   const updateResult = await element.__update();
+  markRendered(element);
+  skippedNodesLength.set(element, updateResult.nodesLength);
   domPointer.increment(updateResult.nodesLength); // bump the dom pointer index forward by the number of nodes within that element's content
   const wrapper = {
     ...newNode,
@@ -1237,8 +1335,19 @@ async function updateFunctionComponent({
   // this func does not seem to be updating the dom pointer index
   //console.log('updateFunctionComponent')
   const standIn = oldNode.element;
+  // see updateClassComponent: unchanged props mean the rendered dom is already correct
+  if (propsAreEqual(standIn.props, newNode[$props], renderedAt(standIn))) {
+    markRendered(standIn); // see updateClassComponent
+    const cachedLength = skippedNodesLength.get(standIn) ?? standIn.__domRegion?.length();
+    if (cachedLength !== undefined) {
+      domPointer.increment(cachedLength);
+      return oldNode;
+    }
+  }
   standIn.props = newNode[$props];
   const updateResult = await standIn.update();
+  markRendered(standIn);
+  skippedNodesLength.set(standIn, updateResult.nodesLength);
   domPointer.increment(updateResult.nodesLength); // bump the dom pointer index forward by the number of nodes within that element's content
   const wrapper = {
     ...newNode,
@@ -1337,7 +1446,7 @@ export async function hotSwapClassComponent(oldElement, NewType) {
   });
   newElement.__domRegion = new DomRegion(parent, domStartIndex, domPointer.index - domStartIndex);
   newElement.__currentContent = renderedContent;
-  newElement.__didMount();
+  queueMount(() => newElement.__didMount());
   wrapper.element = newElement;
   wrapper[$props] = newElement.props;
   newElement.__renderedNode = wrapper;

package/dist/update/pendingMounts.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Defers mount hooks until the dom they belong to is in the document.
+ *
+ * Elements are assembled off document and inserted once their subtree is complete, which
+ * is what React, Vue and Svelte all do -- appending into an already-attached element makes
+ * the browser invalidate style and layout on every child. The cost is that a component
+ * created part way through that build would see a detached node in componentDidMount, where
+ * getBoundingClientRect returns zeros and .focus() does nothing, failing silently rather
+ * than throwing.
+ *
+ * So creation opens a scope, mount hooks queue inside it, and the scope's owner flushes
+ * them once everything it created has been attached. Hooks are queued as their components
+ * finish creating -- children before parents -- and the queue drains in that order, so a
+ * parent's hook can still rely on its children having mounted.
+ */
+export declare function beginMountScope(): void;
+/**
+ * Runs `hook` when the current scope closes, or immediately if there is no scope -- the
+ * dom is already attached in that case, so there is nothing to wait for.
+ */
+export declare function queueMount(hook: () => void): void;
+export declare function endMountScope(): void;
+/** drops anything still queued -- used when a create pass fails and unwinds */
+export declare function discardPendingMounts(): void;
+//# sourceMappingURL=pendingMounts.d.ts.map

package/dist/update/pendingMounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingMounts.d.ts","sourceRoot":"","sources":["../../src/update/pendingMounts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAMjD;AAED,wBAAgB,aAAa,IAAI,IAAI,CAgBpC;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,IAAI,CAI3C"}

package/dist/update/pendingMounts.js

@@ -0,0 +1,55 @@
+/**
+ * Defers mount hooks until the dom they belong to is in the document.
+ *
+ * Elements are assembled off document and inserted once their subtree is complete, which
+ * is what React, Vue and Svelte all do -- appending into an already-attached element makes
+ * the browser invalidate style and layout on every child. The cost is that a component
+ * created part way through that build would see a detached node in componentDidMount, where
+ * getBoundingClientRect returns zeros and .focus() does nothing, failing silently rather
+ * than throwing.
+ *
+ * So creation opens a scope, mount hooks queue inside it, and the scope's owner flushes
+ * them once everything it created has been attached. Hooks are queued as their components
+ * finish creating -- children before parents -- and the queue drains in that order, so a
+ * parent's hook can still rely on its children having mounted.
+ */
+const pending = [];
+let depth = 0;
+let flushing = false;
+export function beginMountScope() {
+  depth++;
+}
+/**
+ * Runs `hook` when the current scope closes, or immediately if there is no scope -- the
+ * dom is already attached in that case, so there is nothing to wait for.
+ */
+export function queueMount(hook) {
+  if (depth === 0) {
+    hook();
+    return;
+  }
+  pending.push(hook);
+}
+export function endMountScope() {
+  if (depth > 0) depth--;
+  if (depth > 0) return;
+  // A hook may create more components, which opens and closes further scopes. Draining
+  // from the front means anything they queue joins the end of this same pass rather than
+  // starting a nested one.
+  if (flushing) return;
+  flushing = true;
+  try {
+    while (pending.length > 0) {
+      const hook = pending.shift();
+      if (hook !== undefined) hook();
+    }
+  } finally {
+    flushing = false;
+  }
+}
+/** drops anything still queued -- used when a create pass fails and unwinds */
+export function discardPendingMounts() {
+  pending.length = 0;
+  depth = 0;
+  flushing = false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tungsten",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "exports": {
     ".": "./dist/index.js",
     "./compat": "./dist/compat/index.js",
+    "./library": "./dist/components/library/index.js",
     "./react-zone": "./dist/zones/react.js",
     "./testing": "./dist/testing/index.js",
     "./*": "./dist/*",
@@ -135,7 +136,8 @@
     "__build": "pnpm clean && pnpm build-prep && pnpm build-watch",
     "build": "run-s -c clean build-prep build-watch",
     "clean": "rimraf intermed dist",
-    "build-once": "rimraf intermed dist && pnpm build-ts-once && pnpm build-babel-once",
+    "build-once": "rimraf intermed dist && pnpm build-ts-once && pnpm build-babel-once && pnpm build-component-styles",
+    "build-component-styles": "node scripts/buildComponentStyles.mjs",
     "build-once-nd": "rimraf intermed dist.building && pnpm build-ts-once && pnpm build-babel-staged && node scripts/syncDist.mjs && node scripts/writeBuildMarker.mjs",
     "build-quick": "pnpm build-watch",
     "build-prep": "pnpm build-ts-once",

package/dist/env/parseEnv.d.ts

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

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

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

package/dist/env/parseEnv.js

@@ -1,14 +0,0 @@
-export {};
-// export function parseEnv(envContent: string): Record<string, string> {
-//     const env: Record<string, string> = {}
-//     //console.log('parseEnv')
-//     const lines = envContent.split('\n')
-//     for (const line of lines) {
-//         //console.log('line', line)
-//         const parts = line.split('=')
-//         if (parts.length === 2) {
-//             env[parts[0].trim()] = parts[1].trim()
-//         }
-//     }
-//     return env
-// }