@stacksjs/stx 0.0.0

package/dist/client.d.ts

@@ -0,0 +1,36 @@
+declare type IslandHandlers = Record<string, () => Promise<any>>
+
+type IslandHydrationFn = (element: any, props: any) => void | Promise<void>
+
+const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined'
+
+async function hydrateIsland(
+  element: any,
+  name: string,
+  handler: () => Promise<any>,
+): Promise<void> {
+  if (!isBrowser) return
+
+  try {
+    const id = element.getAttribute('data-island-id')
+    const propsScript = document.querySelector(`script[data-island-props="${id}"]`)
+    const props = propsScript ? JSON.parse(propsScript.textContent || '{}') : {}
+
+    const module = await handler()
+    const hydrateFn: IslandHydrationFn = module.default || module.hydrate
+
+    if (typeof hydrateFn !== 'function') {
+      console.error(`Island handler for "${name}" does not export a valid hydration function`)
+      return
+    }
+
+    await hydrateFn(element, props)
+
+    element.setAttribute('data-hydrated', 'true')
+  }
+  catch (error) {
+    console.error(`Failed to hydrate island "${name}":`, error)
+  }
+}
+export declare function hydrateIslands(handlers: IslandHandlers): void;
+export declare function preloadIslandHandlers(handlers: IslandHandlers): void;

package/dist/client.js

@@ -0,0 +1,90 @@
+// src/client.ts
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+async function hydrateIsland(element, name, handler) {
+  if (!isBrowser)
+    return;
+  try {
+    const id = element.getAttribute("data-island-id");
+    const propsScript = document.querySelector(`script[data-island-props="${id}"]`);
+    const props = propsScript ? JSON.parse(propsScript.textContent || "{}") : {};
+    const module = await handler();
+    const hydrateFn = module.default || module.hydrate;
+    if (typeof hydrateFn !== "function") {
+      console.error(`Island handler for "${name}" does not export a valid hydration function`);
+      return;
+    }
+    await hydrateFn(element, props);
+    element.setAttribute("data-hydrated", "true");
+  } catch (error) {
+    console.error(`Failed to hydrate island "${name}":`, error);
+  }
+}
+function hydrateIslands(handlers) {
+  if (!isBrowser)
+    return;
+  const islands = document.querySelectorAll("[data-island]");
+  const lazyIslands = [];
+  islands.forEach((island) => {
+    const name = island.getAttribute("data-island");
+    const priority = island.getAttribute("data-priority") || "lazy";
+    if (!name || !handlers[name] || island.getAttribute("data-hydrated") === "true") {
+      return;
+    }
+    if (priority === "eager") {
+      hydrateIsland(island, name, handlers[name]);
+    } else {
+      lazyIslands.push([island, name]);
+    }
+  });
+  if (lazyIslands.length > 0 && "IntersectionObserver" in window) {
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          const element = entry.target;
+          const name = element.getAttribute("data-island");
+          if (name && handlers[name] && element.getAttribute("data-hydrated") !== "true") {
+            hydrateIsland(element, name, handlers[name]);
+            observer.unobserve(element);
+          }
+        }
+      });
+    }, {
+      rootMargin: "200px",
+      threshold: 0
+    });
+    lazyIslands.forEach(([element]) => {
+      observer.observe(element);
+    });
+  } else {
+    setTimeout(() => {
+      lazyIslands.forEach(([element, name]) => {
+        if (element.getAttribute("data-hydrated") !== "true") {
+          hydrateIsland(element, name, handlers[name]);
+        }
+      });
+    }, 1000);
+  }
+}
+function preloadIslandHandlers(handlers) {
+  if (!isBrowser)
+    return;
+  Object.entries(handlers).forEach(([name, getHandler]) => {
+    try {
+      const handlerString = getHandler.toString();
+      const moduleMatch = handlerString.match(/import\(['"](.+)['"]\)/);
+      if (moduleMatch && moduleMatch[1]) {
+        const link = document.createElement("link");
+        link.rel = "modulepreload";
+        link.href = moduleMatch[1];
+        link.setAttribute("data-island-module", name);
+        document.head.appendChild(link);
+      }
+    } catch (error) {
+      console.warn(`Failed to preload island handler for "${name}":`, error);
+    }
+  });
+}
+export {
+  preloadIslandHandlers,
+  hydrateIslands
+};

package/dist/conditionals.d.ts

@@ -0,0 +1,4 @@
+export declare function processConditionals(template: string, context: Record<string, any>, filePath: string): string;
+export declare function processAuthDirectives(template: string, context: Record<string, any>): string;
+export declare function processIssetEmptyDirectives(template: string, context: Record<string, any>, filePath?: string): string;
+export declare function processEnvDirective(template: string, context: Record<string, any>, filePath?: string): string;

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { StxConfig } from './types';
+
+export declare const defaultConfig: StxConfig;
+export declare const config: StxConfig;

package/dist/custom-directives.d.ts

@@ -0,0 +1,6 @@
+import type { CustomDirective, StxOptions } from './types';
+
+export declare function processCustomDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+declare function processDirectiveWithEndTag(template: string, directive: CustomDirective, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+declare function processDirectiveWithoutEndTag(template: string, directive: CustomDirective, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+declare function parseDirectiveParams(paramString: string): string[];

package/dist/docs.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentDoc, DirectiveDoc, TemplateDoc } from './types';
+
+export declare function extractComponentProps(componentPath: string): Promise<ComponentPropDoc[]>;
+export declare function extractComponentDescription(componentPath: string): Promise<string>;
+export declare function generateComponentDoc(componentPath: string, isWebComponent?: boolean, webComponentTag?: string): Promise<ComponentDoc>;
+export declare function findComponentFiles(componentsDir: string): Promise<string[]>;
+export declare function generateComponentsDocs(componentsDir: string, webComponentsConfig?: any): Promise<ComponentDoc[]>;
+export declare function generateTemplatesDocs(templatesDir: string): Promise<TemplateDoc[]>;
+export declare function generateDirectivesDocs(customDirectives?: any[]): Promise<DirectiveDoc[]>;
+export declare function formatDocsAsMarkdown(componentDocs?: ComponentDoc[], templateDocs?: TemplateDoc[], directiveDocs?: DirectiveDoc[], extraContent?: string): string;
+export declare function formatDocsAsHtml(componentDocs?: ComponentDoc[], templateDocs?: TemplateDoc[], directiveDocs?: DirectiveDoc[], extraContent?: string): string;
+export declare function formatDocsAsJson(componentDocs?: ComponentDoc[], templateDocs?: TemplateDoc[], directiveDocs?: DirectiveDoc[], extraContent?: string): string;
+export declare function generateDocs(options: {
+  componentsDir?: string
+  templatesDir?: string
+  webComponentsConfig?: any
+  customDirectives?: any[]
+  config: Partial<DocGeneratorConfig>
+}): Promise<boolean>;
+export declare function docsCommand(options: any): Promise<boolean>;

package/dist/expressions.d.ts

@@ -0,0 +1,9 @@
+export declare type FilterFunction = (value: any, ...args: any[]) => any
+
+let globalContext: Record<string, any> = {}
+export declare function setGlobalContext(context: Record<string, any>): void;
+export declare function escapeHtml(unsafe: string): string;
+export declare function processExpressions(template: string, context: Record<string, any>, filePath: string): string;
+export declare function applyFilters(value: any, filterExpression: string, context: Record<string, any>): any;
+export declare function evaluateExpression(expression: string, context: Record<string, any>, silent?: boolean): any;
+export declare function unescapeHtml(html: string): string;

package/dist/forms.d.ts

@@ -0,0 +1,31 @@
+import type { StxOptions } from './types';
+
+declare function genId(): string;
+export declare function processForms(template: string, context: Record<string, any>, _filePath: string, _options: StxOptions): string;
+export declare function processBasicFormDirectives(template: string, context: Record<string, any>): string;
+export declare function processFormInputDirectives(template: string, context: Record<string, any>): string;
+declare const name: unknown;
+declare const attrs: unknown;
+declare const type: unknown;
+declare const existingClass: unknown;
+declare const attrs: unknown;
+declare const hasError: unknown;
+declare const existingClass: unknown;
+declare const attrs: unknown;
+declare const hasError: unknown;
+declare const existingClass: unknown;
+declare const isSelected: oldValue;
+declare const attrs: unknown;
+declare const isChecked: oldValues;
+declare const existingClass: unknown;
+declare const attrs: unknown;
+declare const isChecked: unknown;
+declare const className: unknown;
+declare const attrs: unknown;
+declare const className: unknown;
+export declare function processErrorDirective(template: string, context: Record<string, any>): string;
+declare function hasFieldError(field: string, context: Record<string, any>): boolean;
+declare function getErrorMessage(field: string, context: Record<string, any>): string;
+declare function getOldValue(field: string, context: Record<string, any>): any;
+declare function parseAttributes(attributesStr: string): string;
+export declare function processFormDirectives(template: string, context: Record<string, any>): string;

package/dist/i18n.d.ts

@@ -0,0 +1,22 @@
+import type { I18nConfig, StxOptions } from './types';
+
+export declare const defaultI18nConfig: I18nConfig;
+declare const translationsCache: Record<string, Record<string, any>>;
+export declare function loadTranslation(locale: string, options: StxOptions): Promise<Record<string, any>>;
+declare function parseYaml(content: string): Promise<Record<string, any>>;
+declare function getFileExtension(format: string): string;
+export declare function getTranslation(key: string,
+  translations: Record<string, any>,
+  fallbackToKey: boolean = true,
+  params: Record<string, any> = {},): string;
+export declare function processTranslateDirective(template: string, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+declare const i18nConfig: {};
+declare const translations: unknown;
+declare const approaches: Array<(() => unknown) | (() => unknown) | (() => unknown)>;
+declare const translation: unknown;
+declare const matches: Array<((...args: any[]) => unknown)>;
+declare const approaches: Array<(() => unknown) | (() => unknown) | (() => unknown)>;
+declare function replaceAsync(str: string, regex: RegExp, asyncFn: (
+    match, ...groups?: any[]
+  )): Promise<string>;
+export declare function createTranslateFilter(translations: Record<string, any>, fallbackToKey?: boolean): (value: string, params?: Record<string, any>) => string;

package/dist/includes.d.ts

@@ -0,0 +1,21 @@
+import type { StxOptions } from './types';
+
+export declare const partialsCache: Map<string, string>;
+export declare function processIncludes(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+declare const includeFilePath: unknown;
+declare const conditionFn: unknown;
+declare const includeFilePath: unknown;
+declare const conditionFn: unknown;
+declare const includeFilePath: unknown;
+declare const matchOffset: unknown;
+declare let pathArray: unknown;
+declare const varsFn: unknown;
+declare const includeFilePath: unknown;
+declare const processed: unknown;
+declare function resolvePath(includePath: string, partialsDir: string, filePath: string): string | null;
+declare let processedIncludes: (...args: any[]) => unknown;
+declare let matchOffset: unknown;
+declare const varsFn: unknown;
+declare const processedContent: unknown;
+export declare function processStackPushDirectives(template: string, stacks: Record<string, string[]>): string;
+export declare function processStackReplacements(template: string, stacks: Record<string, string[]>): string;

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { plugin } from 'bun-plugin-stx';
+
+export type { ComponentDoc, ComponentPropDoc, CustomDirective, DirectiveDoc, DocFormat, DocGeneratorConfig, HydrationConfig, I18nConfig, Island, Middleware, StreamingConfig, StreamRenderer, StxConfig, StxOptions, TemplateDoc, WebComponent, WebComponentConfig } from './types'
+
+export { createTranslateFilter, getTranslation, loadTranslation, processTranslateDirective } from './i18n'
+export { markdownDirectiveHandler, processMarkdownDirectives } from './markdown'
+export { createStreamRenderer, islandDirective, processSectionDirectives, registerStreamingDirectives, streamTemplate } from './streaming'
+export { buildWebComponents, webComponentDirectiveHandler } from './web-components'
+
+export * from './auth'
+export * from './caching'
+export * from './config'
+export * from './custom-directives'
+export * from './docs'
+export * from './expressions'
+export * from './forms'
+export * from './includes'
+export * from './loops'
+export * from './middleware'
+export * from './process'
+export * from './types'
+export * from './utils'
+
+export default plugin;