@stacksjs/stx 0.2.139 → 0.2.141

package/dist/js-ts.js

@@ -36,7 +36,10 @@ async function processCodeBlocks(template, context, filePath, startTag, endTag)
     });
   for (const { fullMatch, content, index } of matches)
     try {
-      const keys = Object.keys(context), values = Object.values(context);
+      const executionContext = {
+        ...context,
+        global: context
+      }, keys = Object.keys(executionContext), values = Object.values(executionContext);
       let strippedContent = content.trim();
       if (startTag === "@ts")
         strippedContent = strippedContent.replace(/interface\s+\w+\s*\{[^}]*\}/g, "").replace(/type\s+\w+\s*=[^;]+;/g, "").replace(/(const|let|var)\s+(\w+)\s*:[^=]+=/g, "$1 $2 =").replace(/(\w+)\s*:[\w<>|&[\],\s]+(?=[,)])/g, "$1").replace(/\)\s*:[\w<>|&[\],\s]+(?=[{=>])/g, ") ").replace(/<[\w<>|&[\],\s]+>/g, "").replace(/\s+as\s[\w<>|&[\],\s]+/g, "");

package/dist/lazy-module.d.ts

@@ -0,0 +1 @@
+export declare function importOnce<T>(key: string, importer: () => Promise<T>): Promise<T>;

package/dist/lazy-module.js

@@ -0,0 +1,18 @@
+const LAZY_MODULE_PROMISES = Symbol.for("stx.lazy-module-promises");
+function modulePromises() {
+  const shared = globalThis;
+  shared[LAZY_MODULE_PROMISES] ??= new Map;
+  return shared[LAZY_MODULE_PROMISES];
+}
+export function importOnce(key, importer) {
+  const promises = modulePromises(), scopedKey = `${import.meta.url}\x00${key}`, pending = promises.get(scopedKey);
+  if (pending)
+    return pending;
+  const imported = importer();
+  promises.set(scopedKey, imported);
+  imported.catch(() => {
+    if (promises.get(scopedKey) === imported)
+      promises.delete(scopedKey);
+  });
+  return imported;
+}

package/dist/process.js

@@ -47,6 +47,7 @@ import { isProduction, isTest } from "./env.js";
 import { warnUnbalancedTags } from "./template-tag-balance.js";
 import { deriveLayoutGroup } from "stx-router/layout-metadata";
 import { initializeComponentClientFactories, injectComponentClientFactories } from "./component-client-factories.js";
+import { importOnce } from "./lazy-module.js";
 export { injectRouterScript } from "./runtime-injection.js";
 export { processJsonDirective, processOnceDirective } from "./misc-directives.js";
 export { validateClientScript } from "./script-validation.js";
@@ -300,7 +301,7 @@ export async function processDirectives(template, context, filePath, options, de
       }
       if (isTopLevel)
         try {
-          const { getStoreScript } = await import("./store-loader.js"), resolvedStoresDir = options.storesDir, storeCode = await getStoreScript(resolvedStoresDir);
+          const { getStoreScript } = await importOnce("stx/store-loader", () => import("./store-loader.js")), resolvedStoresDir = options.storesDir, storeCode = await getStoreScript(resolvedStoresDir);
           if (storeCode) {
             const storeTag = `<script data-stx-stores>${storeCode}</script>`, runtime = findScriptBlockByAttribute(result, "data-stx-runtime");
             if (runtime)
@@ -310,7 +311,7 @@ export async function processDirectives(template, context, filePath, options, de
         } catch {}
       if (isTopLevel)
         try {
-          const { getComposableScript } = await import("./composable-loader.js"), resolvedComposablesDir = options.composablesDir, composableCode = await getComposableScript(resolvedComposablesDir);
+          const { getComposableScript } = await importOnce("stx/composable-loader", () => import("./composable-loader.js")), resolvedComposablesDir = options.composablesDir, composableCode = await getComposableScript(resolvedComposablesDir);
           if (composableCode) {
             const composableTag = `<script data-stx-composables>${composableCode}</script>`, anchor = findScriptBlockByAttribute(result, "data-stx-stores") || findScriptBlockByAttribute(result, "data-stx-runtime");
             if (anchor)
@@ -555,7 +556,7 @@ async function extractServerScriptVariables(output, context, filePath) {
     if (!/\bserver\b/.test(attrs) || !scriptContent.trim())
       continue;
     try {
-      const { extractVariables } = await import("./variable-extractor.js");
+      const { extractVariables } = await importOnce("stx/variable-extractor", () => import("./variable-extractor.js"));
       await extractVariables(scriptContent, context, filePath, { preserveExisting: !0 });
     } catch (e) {
       const err = e instanceof Error ? e : Error(String(e));
@@ -566,7 +567,7 @@ async function extractServerScriptVariables(output, context, filePath) {
 }
 async function interpolateClientScriptExpressions(output, context, filePath) {
   try {
-    const { interpolateScriptsInTemplate } = await import("./expressions.js");
+    const { interpolateScriptsInTemplate } = await importOnce("stx/expressions", () => import("./expressions.js"));
     return interpolateScriptsInTemplate(output, context, { skipServer: !0 });
   } catch (e) {
     const err = e instanceof Error ? e : Error(String(e));
@@ -588,40 +589,40 @@ async function processOtherDirectives(template, context, filePath, options, depe
     output = convertSignalLoopsToAttributes(output, context);
   }
   output = preEvalLiteralReactiveIfs(output);
-  const { processStreamDirectives } = await import("./streaming.js");
+  const { processStreamDirectives } = await importOnce("stx/streaming", () => import("./streaming.js"));
   output = processStreamDirectives(output, context);
   output = processLoops(output, context, filePath, opts);
   output = await processComponents(output, context, filePath, opts, dependencies);
   output = await processDynamicComponents(output, context, filePath, opts, dependencies);
   output = processAnimationDirectives(output, context, filePath, opts);
-  const { processDeferDirectives } = await import("./defer.js");
+  const { processDeferDirectives } = await importOnce("stx/defer", () => import("./defer.js"));
   output = processDeferDirectives(output, context, filePath);
-  const { processTeleportDirectives } = await import("./teleport.js");
+  const { processTeleportDirectives } = await importOnce("stx/teleport", () => import("./teleport.js"));
   output = processTeleportDirectives(output, context, filePath);
-  const { processTransitionDirectives, processTransitionAttributes } = await import("./transitions.js");
+  const { processTransitionDirectives, processTransitionAttributes } = await importOnce("stx/transitions", () => import("./transitions.js"));
   output = processTransitionDirectives(output, context, filePath);
   output = processTransitionAttributes(output);
-  const { processErrorBoundaryDirectives } = await import("./error-boundaries.js");
+  const { processErrorBoundaryDirectives } = await importOnce("stx/error-boundaries", () => import("./error-boundaries.js"));
   output = processErrorBoundaryDirectives(output, context, filePath);
-  const { processSuspenseDirectives } = await import("./suspense.js");
+  const { processSuspenseDirectives } = await importOnce("stx/suspense", () => import("./suspense.js"));
   output = processSuspenseDirectives(output, context, filePath);
-  const { processAsyncDirectives } = await import("./async-components.js");
+  const { processAsyncDirectives } = await importOnce("stx/async-components", () => import("./async-components.js"));
   output = processAsyncDirectives(output, context, filePath);
-  const { processKeepAliveDirectives } = await import("./keep-alive.js");
+  const { processKeepAliveDirectives } = await importOnce("stx/keep-alive", () => import("./keep-alive.js"));
   output = processKeepAliveDirectives(output, context, filePath);
-  const { processVirtualListDirectives, processVirtualGridDirectives, processInfiniteListDirectives } = await import("./virtual-scrolling.js");
+  const { processVirtualListDirectives, processVirtualGridDirectives, processInfiniteListDirectives } = await importOnce("stx/virtual-scrolling", () => import("./virtual-scrolling.js"));
   output = processVirtualListDirectives(output, context, filePath);
   output = processVirtualGridDirectives(output, context, filePath);
   output = processInfiniteListDirectives(output, context, filePath);
-  const { processPartialHydrationDirectives, processStaticDirectives } = await import("./partial-hydration.js");
+  const { processPartialHydrationDirectives, processStaticDirectives } = await importOnce("stx/partial-hydration", () => import("./partial-hydration.js"));
   output = processPartialHydrationDirectives(output, context, filePath);
   output = processStaticDirectives(output);
-  const { processComputedDirectives, processWatchDirectives } = await import("./computed.js");
+  const { processComputedDirectives, processWatchDirectives } = await importOnce("stx/computed", () => import("./computed.js"));
   output = processComputedDirectives(output, context, filePath);
   output = processWatchDirectives(output, context, filePath);
-  const { processFormValidationDirectives } = await import("./forms-validation.js");
+  const { processFormValidationDirectives } = await importOnce("stx/forms-validation", () => import("./forms-validation.js"));
   output = processFormValidationDirectives(output, context, filePath);
-  const { processHeadDirective, processTitleDirective, processMetaDirective, resetHead } = await import("./head.js");
+  const { processHeadDirective, processTitleDirective, processMetaDirective, resetHead } = await importOnce("stx/head", () => import("./head.js"));
   if (!context.__stx_head_preset && !context.__stx_runtime_head)
     resetHead();
   const headResult = processHeadDirective(output);
@@ -673,14 +674,14 @@ async function processOtherDirectives(template, context, filePath, options, depe
   output = addCloakToUnresolvedExpressions(output);
   output = addCloakToConditionalDirectives(output);
   output = processTemplateBindings(output);
-  const { processXElementDirectives } = await import("./x-element.js");
+  const { processXElementDirectives } = await importOnce("stx/x-element", () => import("./x-element.js"));
   output = processXElementDirectives(output);
   const pageFilePath = context.__originalFilePath || filePath, serverData = extractBridgeData(context);
   output = await processSignals(output, opts, pageFilePath, serverData);
   output = processAppearanceBootstrapDirective(output, context);
   output = await runPostProcessingMiddleware(output, context, filePath, opts);
   if (opts.media?.image?.autoSiblings) {
-    const publicDir = opts.publicDir || "public", { rewriteImagesWithSiblings } = await import("./image-optimization/auto-sibling.js");
+    const publicDir = opts.publicDir || "public", { rewriteImagesWithSiblings } = await importOnce("stx/image-optimization/auto-sibling", () => import("./image-optimization/auto-sibling.js"));
     output = await rewriteImagesWithSiblings(output, { publicDir });
   }
   if (opts.seo?.enabled)
@@ -708,7 +709,7 @@ ${snippet}`);
 ${snippet}
 </head>`);
     return html;
-  }, { renderHead, getHead } = await import("./head.js"), headConfig = context.__stx_runtime_head ?? getHead();
+  }, { renderHead, getHead } = await importOnce("stx/head", () => import("./head.js")), headConfig = context.__stx_runtime_head ?? getHead();
   if (headConfig.title || headConfig.meta?.length || headConfig.link?.length) {
     const renderedHead = renderHead(headConfig);
     if (renderedHead)
@@ -723,7 +724,7 @@ ${snippet}
   if (opts.heatmap?.enabled)
     output = injectHeatmap(output, opts);
   if (opts.pwa?.enabled && opts.pwa.autoInject !== !1) {
-    const { injectPwaTags } = await import("./pwa/inject.js");
+    const { injectPwaTags } = await importOnce("stx/pwa/inject", () => import("./pwa/inject.js"));
     output = injectPwaTags(output, opts);
   }
   const hasClientScripts = /<script\b(?![^>]*\bserver\b)[^>]*>[\s\S]*?<\/script>/i.test(output), hasStxUsage = /\bSTX\.\w+/.test(output), alreadyHasRuntime = /window\.STX\s*=/.test(output);
@@ -748,7 +749,7 @@ ${runtimeScript}`);
 ` + output;
   }
   {
-    const { scanScriptTags } = await import("./signal-processing.js"), serverRemoveRanges = [];
+    const { scanScriptTags } = await importOnce("stx/signal-processing", () => import("./signal-processing.js")), serverRemoveRanges = [];
     for (const script of scanScriptTags(output)) {
       if (!/\bserver\b/i.test(script.attrs))
         continue;
@@ -770,7 +771,7 @@ ${runtimeScript}`);
     output = scopedResult.html;
   const eventBindings = context.__stx_event_bindings || [];
   let clientScriptsTransformed = !1;
-  const clientScriptMatches = [], hasColonDirectives = /\s:[a-z][\w.-]*\s*=/.test(output), { scanScriptTags } = await import("./signal-processing.js");
+  const clientScriptMatches = [], hasColonDirectives = /\s:[a-z][\w.-]*\s*=/.test(output), { scanScriptTags } = await importOnce("stx/signal-processing", () => import("./signal-processing.js"));
   for (const s of scanScriptTags(output, {
     skipAttrs: /\bserver\b|\bsrc\s*=|\bdata-stx-scoped\b|\bdata-stx-router\b|\btype\s*=\s*["'](?!(?:text\/javascript|application\/javascript|module)["'])[^"']*["']/
   }))