asjs-express 1.1.0

package/lib/asjs.js

@@ -0,0 +1,1579 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const express = require('express');
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function ensureExtension(name, extension) {
+  return path.extname(name) ? name : `${name}.${extension}`;
+}
+
+function normalizeBooleanOption(value, fallback) {
+  return value === undefined ? fallback : Boolean(value);
+}
+
+function normalizeNumberOption(value, fallback) {
+  const normalized = Number(value);
+  return Number.isFinite(normalized) && normalized >= 0 ? normalized : fallback;
+}
+
+function normalizeAssetMountPath(value) {
+  const rawValue = value === undefined || value === null || value === ''
+    ? '_asjs'
+    : String(value);
+  const normalized = rawValue.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+
+  return `/${normalized || '_asjs'}`;
+}
+
+function joinAssetUrl(basePath, fileName) {
+  return `${normalizeAssetMountPath(basePath)}/${String(fileName).replace(/^\/+/, '')}`;
+}
+
+function appendAssetVersion(url, version) {
+  if (!version) {
+    return url;
+  }
+
+  const separator = url.includes('?') ? '&' : '?';
+  return `${url}${separator}v=${encodeURIComponent(version)}`;
+}
+
+function serializeHtmlAttributes(attributes = {}) {
+  return Object.entries(attributes)
+    .filter(([, value]) => value !== false && value !== null && value !== undefined)
+    .map(([name, value]) => {
+      if (value === true) {
+        return ` ${name}`;
+      }
+
+      return ` ${name}="${escapeHtml(String(value))}"`;
+    })
+    .join('');
+}
+
+function createFileHash(filePath) {
+  try {
+    return crypto
+      .createHash('sha1')
+      .update(fs.readFileSync(filePath))
+      .digest('hex')
+      .slice(0, 10);
+  } catch (error) {
+    return 'dev';
+  }
+}
+
+function getPackageVersion(packagePaths) {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packagePaths.packageJsonPath, 'utf8'));
+    return typeof packageJson.version === 'string' && packageJson.version
+      ? packageJson.version
+      : 'dev';
+  } catch (error) {
+    return 'dev';
+  }
+}
+
+function resolveAssetVersion(filePath, config) {
+  if (config.assetVersion === false) {
+    return '';
+  }
+
+  const baseVersion = typeof config.assetVersion === 'string' && config.assetVersion
+    ? config.assetVersion
+    : (config.packageVersion || 'dev');
+
+  return `${baseVersion}-${createFileHash(filePath)}`;
+}
+
+function createClientAssets(config) {
+  const routerScriptVersion = resolveAssetVersion(config.packagePaths.routerPath, config);
+  const coreStylesheetVersion = resolveAssetVersion(config.packagePaths.stylesheetPath, config);
+  const themeStylesheetVersion = resolveAssetVersion(config.packagePaths.themeStylesheetPath, config);
+
+  return {
+    mountPath: config.assetMountPath,
+    routerScript: appendAssetVersion(
+      joinAssetUrl(config.assetMountPath, 'asjs-router.js'),
+      routerScriptVersion
+    ),
+    coreStylesheet: appendAssetVersion(
+      joinAssetUrl(config.assetMountPath, 'asjs-core.css'),
+      coreStylesheetVersion
+    ),
+    themeStylesheet: appendAssetVersion(
+      joinAssetUrl(config.assetMountPath, 'asjs-theme.css'),
+      themeStylesheetVersion
+    ),
+    versions: {
+      routerScript: routerScriptVersion,
+      coreStylesheet: coreStylesheetVersion,
+      themeStylesheet: themeStylesheetVersion
+    }
+  };
+}
+
+function renderClientTags(assets, options = {}) {
+  const settings = options && typeof options === 'object' ? options : {};
+  const tags = [];
+  const includeTheme = Boolean(settings.theme);
+
+  if (settings.preload) {
+    if (settings.styles !== false) {
+      tags.push(`<link${serializeHtmlAttributes({
+        rel: 'preload',
+        as: 'style',
+        href: assets.coreStylesheet
+      })}>`);
+    }
+
+    if (settings.script !== false) {
+      tags.push(`<link${serializeHtmlAttributes({
+        rel: 'preload',
+        as: 'script',
+        href: assets.routerScript
+      })}>`);
+    }
+
+    if (includeTheme) {
+      tags.push(`<link${serializeHtmlAttributes({
+        rel: 'preload',
+        as: 'style',
+        href: assets.themeStylesheet
+      })}>`);
+    }
+  }
+
+  if (settings.styles !== false) {
+    tags.push(`<link${serializeHtmlAttributes({
+      rel: 'stylesheet',
+      href: assets.coreStylesheet,
+      ...(settings.styleAttrs || {})
+    })}>`);
+  }
+
+  if (includeTheme) {
+    tags.push(`<link${serializeHtmlAttributes({
+      rel: 'stylesheet',
+      href: assets.themeStylesheet,
+      ...(settings.themeAttrs || {})
+    })}>`);
+  }
+
+  if (settings.script !== false) {
+    const scriptAttributes = {
+      src: assets.routerScript,
+      ...(settings.module ? { type: 'module' } : {}),
+      ...((settings.async || settings.defer === false || settings.module) ? {} : { defer: true }),
+      ...(settings.async ? { async: true } : {}),
+      ...(settings.scriptAttrs || {})
+    };
+
+    tags.push(`<script${serializeHtmlAttributes(scriptAttributes)}></script>`);
+  }
+
+  return tags.join('\n');
+}
+
+function normalizeFormMode(value, fallback = 'view') {
+  const normalized = String(value || fallback || 'view').toLowerCase();
+  return ['view', 'json'].includes(normalized) ? normalized : (fallback || 'view');
+}
+
+function normalizeFormSwap(value, fallback = 'replace') {
+  const normalized = String(value || fallback || 'replace').toLowerCase();
+  return ['replace', 'append', 'prepend'].includes(normalized)
+    ? normalized
+    : (fallback || 'replace');
+}
+
+function normalizeFormOptions(value, fallback = null) {
+  const base = fallback
+    ? { ...fallback }
+    : {
+      enabled: true,
+      selector: 'form[data-asjs-form], form[data-webas-submit]',
+      mode: 'view',
+      history: false,
+      resetOnSuccess: false,
+      target: '',
+      swap: 'replace'
+    };
+
+  if (value === undefined) {
+    return base;
+  }
+
+  if (value === false || value === null) {
+    return {
+      ...base,
+      enabled: false
+    };
+  }
+
+  if (value === true) {
+    return {
+      ...base,
+      enabled: true
+    };
+  }
+
+  if (typeof value === 'string') {
+    return {
+      ...base,
+      enabled: true,
+      selector: value
+    };
+  }
+
+  if (value && typeof value === 'object') {
+    return {
+      ...base,
+      enabled: normalizeBooleanOption(value.enabled, base.enabled),
+      selector: value.selector ? String(value.selector) : base.selector,
+      mode: normalizeFormMode(value.mode, base.mode),
+      history: normalizeBooleanOption(value.history, base.history),
+      resetOnSuccess: normalizeBooleanOption(value.resetOnSuccess, base.resetOnSuccess),
+      target: value.target ? String(value.target) : base.target,
+      swap: normalizeFormSwap(value.swap, base.swap)
+    };
+  }
+
+  return base;
+}
+
+function renderFormAttrs(asjs, options = {}) {
+  const forms = asjs && asjs.forms ? asjs.forms : normalizeFormOptions(true);
+  const settings = options && typeof options === 'object' ? options : {};
+  const attributes = {
+    method: settings.method || 'post',
+    action: settings.action || undefined,
+    enctype: settings.enctype || undefined,
+    novalidate: settings.noValidate ? true : undefined,
+    'data-asjs-form': settings.enabled === false ? undefined : 'true',
+    'data-asjs-form-mode': settings.mode ? normalizeFormMode(settings.mode, forms.mode) : undefined,
+    'data-asjs-form-history': Object.prototype.hasOwnProperty.call(settings, 'history')
+      ? (settings.history ? 'true' : 'false')
+      : undefined,
+    'data-asjs-form-reset-on-success': Object.prototype.hasOwnProperty.call(settings, 'resetOnSuccess')
+      ? (settings.resetOnSuccess ? 'true' : 'false')
+      : undefined,
+    'data-asjs-form-target': settings.target || undefined,
+    'data-asjs-form-swap': settings.swap ? normalizeFormSwap(settings.swap, forms.swap) : undefined,
+    'data-asjs-transition': settings.transition || undefined,
+    ...((settings.attrs && typeof settings.attrs === 'object') ? settings.attrs : {})
+  };
+
+  return serializeHtmlAttributes(attributes);
+}
+
+function normalizePluginList(value) {
+  if (Array.isArray(value)) {
+    return value.filter(Boolean);
+  }
+
+  return value ? [value] : [];
+}
+
+function registerHook(registry, name, handler) {
+  if (!(registry instanceof Map) || typeof name !== 'string' || typeof handler !== 'function') {
+    return;
+  }
+
+  const key = name.trim();
+  if (!key) {
+    return;
+  }
+
+  if (!registry.has(key)) {
+    registry.set(key, []);
+  }
+
+  registry.get(key).push(handler);
+}
+
+function createHookRegistry(inputHooks = {}) {
+  const registry = new Map();
+
+  if (!inputHooks || typeof inputHooks !== 'object') {
+    return registry;
+  }
+
+  Object.entries(inputHooks).forEach(([name, handlers]) => {
+    const normalizedHandlers = Array.isArray(handlers) ? handlers : [handlers];
+
+    normalizedHandlers.forEach((handler) => {
+      registerHook(registry, name, handler);
+    });
+  });
+
+  return registry;
+}
+
+function runSyncHooks(registry, name, context) {
+  const handlers = registry instanceof Map ? (registry.get(name) || []) : [];
+
+  return handlers.reduce((currentContext, handler) => {
+    const result = handler(currentContext);
+
+    if (result && typeof result === 'object') {
+      return {
+        ...currentContext,
+        ...result
+      };
+    }
+
+    return currentContext;
+  }, context);
+}
+
+function runHookChain(registry, name, context) {
+  const handlers = registry instanceof Map ? (registry.get(name) || []) : [];
+
+  return handlers.reduce((promise, handler) => {
+    return promise.then((currentContext) => {
+      return Promise.resolve(handler(currentContext)).then((result) => {
+        if (result && typeof result === 'object') {
+          return {
+            ...currentContext,
+            ...result
+          };
+        }
+
+        return currentContext;
+      });
+    });
+  }, Promise.resolve(context));
+}
+
+function applyAsjsPlugin(plugin, api) {
+  if (!plugin) {
+    return;
+  }
+
+  if (typeof plugin === 'function') {
+    plugin(api);
+    return;
+  }
+
+  const candidate = ['setup', 'install', 'register']
+    .map((key) => plugin[key])
+    .find((handler) => typeof handler === 'function');
+
+  if (candidate) {
+    candidate.call(plugin, api);
+  }
+}
+
+function renderBodyAttrs(asjs, extraAttributes = {}) {
+  return serializeHtmlAttributes({
+    'data-asjs-transition': asjs.transition.enabled ? asjs.transition.name : 'none',
+    'data-asjs-transition-duration': asjs.transition.duration,
+    'data-asjs-prefetch': asjs.prefetch ? 'true' : 'false',
+    'data-asjs-prefetch-ttl': asjs.prefetchTtl,
+    'data-asjs-loading-bar': asjs.loadingBar ? 'true' : 'false',
+    'data-asjs-forms': asjs.forms && asjs.forms.enabled ? 'true' : 'false',
+    'data-asjs-form-selector': asjs.forms ? asjs.forms.selector : undefined,
+    'data-asjs-form-mode': asjs.forms ? asjs.forms.mode : undefined,
+    'data-asjs-form-history': asjs.forms && asjs.forms.history ? 'true' : 'false',
+    'data-asjs-form-reset-on-success': asjs.forms && asjs.forms.resetOnSuccess ? 'true' : 'false',
+    'data-asjs-form-target': asjs.forms && asjs.forms.target ? asjs.forms.target : undefined,
+    'data-asjs-form-swap': asjs.forms ? asjs.forms.swap : undefined,
+    ...extraAttributes
+  });
+}
+
+function renderViewAttrs(asjs, extraAttributes = {}) {
+  return serializeHtmlAttributes({
+    'data-asjs-view': true,
+    'data-asjs-transition': asjs.transition.enabled ? asjs.transition.name : 'none',
+    'data-asjs-transition-duration': asjs.transition.duration,
+    ...extraAttributes
+  });
+}
+
+function renderProgressMarkup() {
+  return '<div class="asjs-progress" data-asjs-progress aria-hidden="true"><span class="asjs-progress-bar"></span></div>';
+}
+
+function createAsjsViewModel(inputAsjs, config, overrides = {}) {
+  const current = inputAsjs && typeof inputAsjs === 'object' ? inputAsjs : {};
+  const assets = config.clientAssets || createClientAssets(config);
+  const transition = Object.prototype.hasOwnProperty.call(overrides, 'transition')
+    ? normalizeTransitionOptions(overrides.transition, config.transitions)
+    : normalizeTransitionOptions(current.transition, config.transitions);
+
+  const viewModel = {
+    ...current,
+    debug: config.debug,
+    transition,
+    prefetch: Object.prototype.hasOwnProperty.call(current, 'prefetch')
+      ? Boolean(current.prefetch)
+      : config.prefetch,
+    prefetchTtl: Object.prototype.hasOwnProperty.call(current, 'prefetchTtl')
+      ? normalizeNumberOption(current.prefetchTtl, config.prefetchTtl)
+      : config.prefetchTtl,
+    loadingBar: Object.prototype.hasOwnProperty.call(current, 'loadingBar')
+      ? Boolean(current.loadingBar)
+      : config.loadingBar,
+    forms: Object.prototype.hasOwnProperty.call(current, 'forms')
+      ? normalizeFormOptions(current.forms, config.forms)
+      : normalizeFormOptions(undefined, config.forms),
+    cache: Object.prototype.hasOwnProperty.call(current, 'cache')
+      ? Boolean(current.cache)
+      : config.cache,
+    assets,
+    assetVersions: assets.versions
+  };
+
+  viewModel.clientTags = (options) => renderClientTags(assets, options);
+  viewModel.bodyAttrs = (extraAttributes) => renderBodyAttrs(viewModel, extraAttributes);
+  viewModel.viewAttrs = (extraAttributes) => renderViewAttrs(viewModel, extraAttributes);
+  viewModel.formAttrs = (options) => renderFormAttrs(viewModel, options);
+  viewModel.progressMarkup = () => renderProgressMarkup();
+
+  return viewModel;
+}
+
+function normalizeComponentName(name, extension = 'asjs') {
+  return ensureExtension(String(name).replace(/\\/g, '/'), extension);
+}
+
+function normalizeComponentSpec(spec) {
+  if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
+    return {
+      props: spec && typeof spec === 'object' ? spec : {},
+      strict: false
+    };
+  }
+
+  if (Object.prototype.hasOwnProperty.call(spec, 'props') || Object.prototype.hasOwnProperty.call(spec, 'schema')) {
+    return {
+      props: spec.props || spec.schema || {},
+      strict: Boolean(spec.strict)
+    };
+  }
+
+  return {
+    props: spec,
+    strict: false
+  };
+}
+
+function normalizeComponentRegistry(components = {}, extension = 'asjs') {
+  const registry = {};
+
+  Object.entries(components).forEach(([name, spec]) => {
+    registry[normalizeComponentName(name, extension)] = normalizeComponentSpec(spec);
+  });
+
+  return registry;
+}
+
+function normalizeTypeList(type) {
+  if (type === undefined || type === null || type === 'any') {
+    return ['any'];
+  }
+
+  return Array.isArray(type) ? type : [type];
+}
+
+function getTypeLabel(type) {
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  if (type === String) {
+    return 'string';
+  }
+
+  if (type === Number) {
+    return 'number';
+  }
+
+  if (type === Boolean) {
+    return 'boolean';
+  }
+
+  if (type === Array) {
+    return 'array';
+  }
+
+  if (type === Object) {
+    return 'object';
+  }
+
+  if (type === Date) {
+    return 'date';
+  }
+
+  return type && type.name ? type.name : 'custom';
+}
+
+function getValueType(value) {
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+
+  if (value instanceof Date) {
+    return 'date';
+  }
+
+  if (value === null) {
+    return 'null';
+  }
+
+  return typeof value;
+}
+
+function matchesExpectedType(value, expected) {
+  if (expected === 'any') {
+    return true;
+  }
+
+  if (typeof expected === 'string') {
+    if (expected === 'array') {
+      return Array.isArray(value);
+    }
+
+    if (expected === 'date') {
+      return value instanceof Date;
+    }
+
+    if (expected === 'null') {
+      return value === null;
+    }
+
+    if (expected === 'object') {
+      return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date);
+    }
+
+    return typeof value === expected;
+  }
+
+  if (expected === String) {
+    return typeof value === 'string';
+  }
+
+  if (expected === Number) {
+    return typeof value === 'number' && !Number.isNaN(value);
+  }
+
+  if (expected === Boolean) {
+    return typeof value === 'boolean';
+  }
+
+  if (expected === Array) {
+    return Array.isArray(value);
+  }
+
+  if (expected === Object) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date);
+  }
+
+  if (expected === Date) {
+    return value instanceof Date;
+  }
+
+  return typeof expected === 'function' ? value instanceof expected : false;
+}
+
+function normalizePropRule(rule) {
+  if (typeof rule === 'string' || Array.isArray(rule) || typeof rule === 'function') {
+    return {
+      required: true,
+      hasDefault: false,
+      defaultValue: undefined,
+      types: normalizeTypeList(rule),
+      validate: null,
+      message: null
+    };
+  }
+
+  if (rule && typeof rule === 'object') {
+    return {
+      required: rule.required !== false && !Object.prototype.hasOwnProperty.call(rule, 'default'),
+      hasDefault: Object.prototype.hasOwnProperty.call(rule, 'default'),
+      defaultValue: rule.default,
+      types: normalizeTypeList(rule.type || 'any'),
+      validate: typeof rule.validate === 'function' ? rule.validate : null,
+      message: rule.message || null
+    };
+  }
+
+  return {
+    required: false,
+    hasDefault: false,
+    defaultValue: undefined,
+    types: ['any'],
+    validate: null,
+    message: null
+  };
+}
+
+function resolveDefaultValue(rule, props) {
+  if (!rule.hasDefault) {
+    return undefined;
+  }
+
+  return typeof rule.defaultValue === 'function' ? rule.defaultValue(props) : rule.defaultValue;
+}
+
+function validateComponentProps(componentName, inputProps, schema = {}, options = {}) {
+  const props = inputProps && typeof inputProps === 'object' ? { ...inputProps } : {};
+  const validatedProps = { ...props };
+  const strict = Boolean(options.strict);
+
+  Object.entries(schema).forEach(([propName, rawRule]) => {
+    const rule = normalizePropRule(rawRule);
+    const hasValue = Object.prototype.hasOwnProperty.call(props, propName) && props[propName] !== undefined;
+
+    if (!hasValue) {
+      if (rule.hasDefault) {
+        validatedProps[propName] = resolveDefaultValue(rule, validatedProps);
+        return;
+      }
+
+      if (rule.required) {
+        throw new TypeError(`ASJS component props hatasi (${componentName}): "${propName}" gerekli.`);
+      }
+
+      return;
+    }
+
+    const value = props[propName];
+    const validType = rule.types.includes('any') || rule.types.some((expected) => matchesExpectedType(value, expected));
+
+    if (!validType) {
+      throw new TypeError(
+        `ASJS component props hatasi (${componentName}): "${propName}" beklenen tip ${rule.types.map(getTypeLabel).join(' | ')}, gelen ${getValueType(value)}.`
+      );
+    }
+
+    if (rule.validate) {
+      const validationResult = rule.validate(value, validatedProps);
+
+      if (validationResult !== true && validationResult !== undefined) {
+        throw new TypeError(
+          typeof validationResult === 'string'
+            ? validationResult
+            : (rule.message || `ASJS component props hatasi (${componentName}): "${propName}" dogrulamasi basarisiz.`)
+        );
+      }
+    }
+  });
+
+  if (strict) {
+    Object.keys(props).forEach((propName) => {
+      if (!Object.prototype.hasOwnProperty.call(schema, propName)) {
+        throw new TypeError(`ASJS component props hatasi (${componentName}): tanimsiz prop "${propName}".`);
+      }
+    });
+  }
+
+  return validatedProps;
+}
+
+function getCompiledTemplate(filePath, runtime) {
+  if (!runtime.cacheEnabled) {
+    return compileTemplate(fs.readFileSync(filePath, 'utf8'), filePath);
+  }
+
+  const stats = fs.statSync(filePath);
+  const cached = runtime.templateCache.get(filePath);
+
+  if (cached && cached.mtimeMs === stats.mtimeMs) {
+    return cached.template;
+  }
+
+  const template = compileTemplate(fs.readFileSync(filePath, 'utf8'), filePath);
+
+  runtime.templateCache.set(filePath, {
+    mtimeMs: stats.mtimeMs,
+    template
+  });
+
+  return template;
+}
+
+function resolveComponentSpec(templateName, runtime, explicitSchema) {
+  if (explicitSchema) {
+    return normalizeComponentSpec(explicitSchema);
+  }
+
+  return runtime.components[normalizeComponentName(templateName, runtime.extension)] || null;
+}
+
+function normalizeTransitionOptions(value, fallback = null) {
+  if (value === undefined) {
+    return fallback
+      ? { ...fallback }
+      : { enabled: false, name: 'none', duration: 0 };
+  }
+
+  if (value === false || value === null || value === 'none') {
+    return { enabled: false, name: 'none', duration: 0 };
+  }
+
+  if (value === true) {
+    return { enabled: true, name: 'fade', duration: 260 };
+  }
+
+  if (typeof value === 'string') {
+    return { enabled: true, name: value, duration: 260 };
+  }
+
+  if (typeof value === 'object') {
+    const enabled = value.enabled !== false;
+    const duration = Number.isFinite(Number(value.duration)) && Number(value.duration) > 0
+      ? Number(value.duration)
+      : 260;
+
+    return {
+      enabled,
+      name: enabled ? String(value.name || 'fade') : 'none',
+      duration: enabled ? duration : 0
+    };
+  }
+
+  return fallback
+    ? { ...fallback }
+    : { enabled: false, name: 'none', duration: 0 };
+}
+
+function resolveTemplatePath(name, currentFile, viewsDir, extension) {
+  const normalizedName = ensureExtension(name, extension);
+
+  if (path.isAbsolute(normalizedName)) {
+    return normalizedName;
+  }
+
+  if (normalizedName.startsWith('./') || normalizedName.startsWith('../')) {
+    return path.resolve(path.dirname(currentFile), normalizedName);
+  }
+
+  return path.resolve(viewsDir, normalizedName);
+}
+
+function compileTemplate(source, filename) {
+  const matcher = /<%[-=]?[\s\S]+?%>/g;
+  let cursor = 0;
+  let match;
+
+  const chunks = [
+    'let __output = "";',
+    'const __append = (value) => { if (value !== undefined && value !== null) { __output += String(value); } };'
+  ];
+
+  while ((match = matcher.exec(source)) !== null) {
+    const text = source.slice(cursor, match.index);
+    if (text) {
+      chunks.push(`__output += ${JSON.stringify(text)};`);
+    }
+
+    const tag = match[0];
+    const body = tag.slice(tag.startsWith('<%=') || tag.startsWith('<%-') ? 3 : 2, -2).trim();
+
+    if (tag.startsWith('<%=')) {
+      chunks.push(`__output += __escape(${body});`);
+    } else if (tag.startsWith('<%-')) {
+      chunks.push(`__append(${body});`);
+    } else {
+      chunks.push(body);
+    }
+
+    cursor = match.index + tag.length;
+  }
+
+  const tail = source.slice(cursor);
+  if (tail) {
+    chunks.push(`__output += ${JSON.stringify(tail)};`);
+  }
+
+  chunks.push('return __output;');
+
+  try {
+    return new Function(
+      '__locals',
+      '__helpers',
+      '__escape',
+      `with (__helpers) { with (__locals) { ${chunks.join('\n')} } }`
+    );
+  } catch (error) {
+    error.message = `ASJS derleme hatasi (${filename}): ${error.message}`;
+    throw error;
+  }
+}
+
+function renderTemplateFile(filePath, locals, runtime) {
+  const template = getCompiledTemplate(filePath, runtime);
+  const renderState = runtime.state || { layout: null };
+
+  const helpers = {
+    escape: escapeHtml,
+    raw(value) {
+      return value == null ? '' : String(value);
+    },
+    print(...values) {
+      return values.filter((value) => value != null).join('');
+    },
+    layout(name) {
+      renderState.layout = name;
+      return '';
+    },
+    include(templateName, extraLocals = {}) {
+      const includePath = resolveTemplatePath(
+        templateName,
+        filePath,
+        runtime.viewsDir,
+        runtime.extension
+      );
+
+      return renderTemplateFile(
+        includePath,
+        { ...locals, ...extraLocals },
+        {
+          ...runtime,
+          state: { layout: null }
+        }
+      ).html;
+    },
+    props(schema, values, componentName = path.basename(filePath)) {
+      const spec = normalizeComponentSpec(schema);
+      return validateComponentProps(componentName, values, spec.props, { strict: spec.strict });
+    },
+    defineProps(schema, values, componentName = path.basename(filePath)) {
+      const spec = normalizeComponentSpec(schema);
+      return validateComponentProps(componentName, values, spec.props, { strict: spec.strict });
+    },
+    component(templateName, componentProps = {}, schema) {
+      const includePath = resolveTemplatePath(
+        templateName,
+        filePath,
+        runtime.viewsDir,
+        runtime.extension
+      );
+      const spec = resolveComponentSpec(templateName, runtime, schema);
+      const validatedProps = spec
+        ? validateComponentProps(templateName, componentProps, spec.props, { strict: spec.strict })
+        : componentProps;
+
+      return renderTemplateFile(
+        includePath,
+        { ...locals, ...validatedProps },
+        {
+          ...runtime,
+          state: { layout: null }
+        }
+      ).html;
+    }
+  };
+
+  try {
+    return {
+      html: template(locals, helpers, escapeHtml),
+      state: renderState
+    };
+  } catch (error) {
+    error.message = `ASJS render hatasi (${filePath}): ${error.message}`;
+    throw error;
+  }
+}
+
+function createAsjsEngine(options = {}) {
+  const extension = String(options.extension || 'asjs').replace(/^\./, '');
+
+  return function asjsEngine(filePath, data, callback) {
+    try {
+      const viewsDir = options.viewsDir || data.settings?.views || path.dirname(filePath);
+      const initialLayout = Object.prototype.hasOwnProperty.call(data, 'layout')
+        ? data.layout
+        : options.defaultLayout || null;
+
+      const locals = {
+        ...data
+      };
+
+      delete locals.layout;
+      locals.asjs = createAsjsViewModel(locals.asjs, options);
+
+      const pageState = { layout: initialLayout };
+      const page = renderTemplateFile(filePath, locals, {
+        cacheEnabled: options.cache !== false,
+        components: options.components || {},
+        extension,
+        templateCache: options.templateCache || new Map(),
+        viewsDir,
+        state: pageState
+      });
+
+      let html = page.html;
+
+      if (pageState.layout) {
+        const layoutPath = resolveTemplatePath(pageState.layout, filePath, viewsDir, extension);
+        html = renderTemplateFile(layoutPath, {
+          ...locals,
+          asjs: createAsjsViewModel(locals.asjs, options),
+          body: html
+        }, {
+          cacheEnabled: options.cache !== false,
+          components: options.components || {},
+          extension,
+          templateCache: options.templateCache || new Map(),
+          viewsDir,
+          state: { layout: null }
+        }).html;
+      }
+
+      callback(null, html);
+    } catch (error) {
+      callback(error);
+    }
+  };
+}
+
+function createAsjsConfig(options = {}) {
+  const extension = String(options.extension || 'asjs').replace(/^\./, '');
+  const packagePaths = getAsjsPackagePaths();
+  const packageVersion = getPackageVersion(packagePaths);
+  const assetMountPath = normalizeAssetMountPath(options.assetMountPath);
+  const rootDir = options.rootDir || process.cwd();
+
+  const config = {
+    extension,
+    assetMountPath,
+    rootDir,
+    viewsDir: options.viewsDir || path.join(rootDir, 'views'),
+    publicDir: options.publicDir || null,
+    defaultLayout: options.defaultLayout || null,
+    debug: Boolean(options.debug),
+    cache: normalizeBooleanOption(options.cache, !options.debug),
+    navItems: Array.isArray(options.navItems) ? options.navItems : [],
+    locals: options.locals && typeof options.locals === 'object' ? options.locals : {},
+    components: normalizeComponentRegistry(options.components || {}, extension),
+    templateCache: new Map(),
+    transitions: normalizeTransitionOptions(options.transitions),
+    prefetch: normalizeBooleanOption(options.prefetch, true),
+    prefetchTtl: normalizeNumberOption(options.prefetchTtl, 30000),
+    loadingBar: normalizeBooleanOption(options.loadingBar, true),
+    forms: normalizeFormOptions(
+      Object.prototype.hasOwnProperty.call(options, 'forms') ? options.forms : true
+    ),
+    hooks: createHookRegistry(options.hooks),
+    plugins: normalizePluginList(options.plugins),
+    packagePaths,
+    packageVersion,
+    assetVersion: Object.prototype.hasOwnProperty.call(options, 'assetVersion')
+      ? options.assetVersion
+      : packageVersion,
+    serveClientAssets: normalizeBooleanOption(options.serveClientAssets, true)
+  };
+
+  config.clientAssets = createClientAssets(config);
+
+  return config;
+}
+
+function getAsjsPackagePaths() {
+  const rootDir = path.resolve(__dirname, '..');
+  const clientDir = path.join(__dirname, 'client');
+
+  return {
+    rootDir,
+    clientDir,
+    entryPath: path.join(rootDir, 'index.js'),
+    packageJsonPath: path.join(rootDir, 'package.json'),
+    routerPath: path.join(clientDir, 'asjs-router.js'),
+    stylesheetPath: path.join(clientDir, 'asjs-core.css'),
+    themeStylesheetPath: path.join(clientDir, 'asjs-theme.css')
+  };
+}
+
+function renderDebugErrorPage(error, context = {}) {
+  const status = Number(context.status || error.status || 500);
+  const title = context.title || 'ASJS Debug Hatası';
+  const method = escapeHtml(context.method || 'GET');
+  const requestPath = escapeHtml(context.requestPath || '/');
+  const timestamp = escapeHtml(new Date().toLocaleString('tr-TR'));
+  const message = escapeHtml(error.message || 'Bilinmeyen hata');
+  const errorName = escapeHtml(error.name || 'Error');
+  const stackLines = String(error.stack || error.message || 'Stack bilgisi yok')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const stack = escapeHtml(stackLines.join('\n'));
+  const primaryFrame = escapeHtml(stackLines[1] || 'Çerçeve bilgisi yok');
+  const cause = error.cause ? escapeHtml(String(error.cause.stack || error.cause.message || error.cause)) : '';
+  const templateMatch = String(error.message || '').match(/\(([^)]+\.asjs)\)/);
+  const templatePath = escapeHtml(templateMatch ? templateMatch[1] : (context.templatePath || 'Bulunamadı'));
+  const hintItems = [
+    'Şablon içinde <% %> bloklarının açılıp kapandığını kontrol et.',
+    'Layout ve include yollarının views klasörüne göre doğru çözüldüğünden emin ol.',
+    'component() kullanıyorsan zorunlu props alanlarının tam gönderildiğini doğrula.',
+    'Özel CSS veya script ekliyorsan bunların ASJS body ve view alanlarını bozmadığını kontrol et.'
+  ];
+  const environmentItems = [
+    { label: 'Hata türü', value: errorName },
+    { label: 'İstek', value: `${method} ${requestPath}` },
+    { label: 'Şablon', value: templatePath },
+    { label: 'İlk çerçeve', value: primaryFrame },
+    { label: 'Zaman', value: timestamp },
+    { label: 'Sürüm', value: escapeHtml(context.packageVersion || 'dev') }
+  ];
+
+  return `<!DOCTYPE html>
+<html lang="tr">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <style>
+      :root {
+        --bg: #08111f;
+        --panel: rgba(11, 21, 38, 0.88);
+        --panel-strong: rgba(17, 31, 56, 0.96);
+        --text: #eef4fb;
+        --muted: #a7b2c6;
+        --accent: #ff8a65;
+        --accent-2: #63e6be;
+        --accent-3: #5fd2ff;
+        --line: rgba(255, 255, 255, 0.08);
+        --radius-xl: 30px;
+        --radius-lg: 22px;
+        --radius-md: 16px;
+        --shadow: 0 34px 90px rgba(0, 0, 0, 0.38);
+      }
+
+      * { box-sizing: border-box; }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        color: var(--text);
+        font-family: "Space Grotesk", "Segoe UI", sans-serif;
+        background:
+          radial-gradient(circle at top left, rgba(255, 138, 101, 0.18), transparent 28%),
+          radial-gradient(circle at top right, rgba(99, 230, 190, 0.16), transparent 30%),
+          linear-gradient(140deg, #040a14, #08111f 52%, #10203b);
+      }
+
+      body::before {
+        content: "";
+        position: fixed;
+        inset: 0;
+        pointer-events: none;
+        background-image:
+          linear-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+        background-size: 42px 42px;
+        mask-image: radial-gradient(circle at center, black 55%, transparent 92%);
+      }
+
+      .shell {
+        width: min(1220px, calc(100% - 32px));
+        margin: 24px auto 40px;
+        position: relative;
+        z-index: 1;
+      }
+
+      .hero,
+      .panel,
+      .stack-panel,
+      .meta-card {
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: var(--radius-xl);
+        backdrop-filter: blur(18px);
+        box-shadow: var(--shadow);
+      }
+
+      .hero {
+        padding: 30px;
+        display: grid;
+        gap: 26px;
+      }
+
+      .eyebrow {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        width: fit-content;
+        padding: 8px 12px;
+        border-radius: 999px;
+        background: rgba(255, 138, 101, 0.12);
+        color: var(--accent);
+        font-size: 0.84rem;
+        text-transform: uppercase;
+        letter-spacing: 0.08em;
+      }
+
+      .hero-top {
+        display: grid;
+        grid-template-columns: 1.2fr 0.8fr;
+        gap: 20px;
+        align-items: start;
+      }
+
+      h1 {
+        margin: 16px 0 10px;
+        font-size: clamp(2.6rem, 7vw, 5.2rem);
+        line-height: 0.96;
+        letter-spacing: -0.05em;
+      }
+
+      p,
+      li {
+        color: var(--muted);
+        line-height: 1.7;
+      }
+
+      .grid {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 18px;
+      }
+
+      .panel {
+        padding: 22px;
+      }
+
+      .meta-grid {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 16px;
+      }
+
+      .meta-card {
+        padding: 18px;
+      }
+
+      .headline {
+        margin: 0;
+        font-size: 1.3rem;
+        line-height: 1.3;
+      }
+
+      .status-badge {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        padding: 10px 14px;
+        border-radius: 999px;
+        background: rgba(255, 138, 101, 0.12);
+        color: var(--text);
+        font-weight: 700;
+      }
+
+      .status-dot {
+        width: 10px;
+        height: 10px;
+        border-radius: 50%;
+        background: linear-gradient(135deg, var(--accent), #ffb38a);
+        box-shadow: 0 0 18px rgba(255, 138, 101, 0.48);
+      }
+
+      .label {
+        display: block;
+        color: var(--muted);
+        font-size: 0.9rem;
+        margin-bottom: 8px;
+      }
+
+      .value {
+        display: block;
+        color: var(--text);
+        font-weight: 700;
+        word-break: break-word;
+      }
+
+      .section-title {
+        margin: 0 0 12px;
+        font-size: 1.08rem;
+      }
+
+      .stack-grid {
+        display: grid;
+        grid-template-columns: 1.1fr 0.9fr;
+        gap: 18px;
+      }
+
+      .stack-panel {
+        padding: 22px;
+      }
+
+      .stack {
+        margin-top: 12px;
+        padding: 20px;
+        border-radius: var(--radius-lg);
+        background: rgba(5, 10, 19, 0.82);
+        border: 1px solid rgba(255, 255, 255, 0.07);
+        overflow-x: auto;
+      }
+
+      pre {
+        margin: 0;
+        white-space: pre-wrap;
+        word-break: break-word;
+        font-family: "Cascadia Code", "Consolas", monospace;
+        color: #f6f8fb;
+        line-height: 1.65;
+      }
+
+      .summary-list,
+      .tips {
+        margin: 0;
+        padding-left: 18px;
+        display: grid;
+        gap: 10px;
+      }
+
+      .tips strong {
+        color: var(--accent-2);
+      }
+
+      .summary-list strong {
+        color: var(--accent-3);
+      }
+
+      .callout {
+        margin-top: 10px;
+        padding: 16px 18px;
+        border-radius: var(--radius-md);
+        background: linear-gradient(180deg, rgba(17, 31, 56, 0.9), rgba(10, 20, 36, 0.84));
+        border: 1px solid rgba(255, 255, 255, 0.08);
+      }
+
+      code {
+        font-family: "Cascadia Code", "Consolas", monospace;
+        font-size: 0.95em;
+      }
+
+      .subtle {
+        color: var(--muted);
+      }
+
+      details {
+        margin-top: 16px;
+        border-top: 1px solid rgba(255, 255, 255, 0.08);
+        padding-top: 14px;
+      }
+
+      summary {
+        cursor: pointer;
+        color: var(--text);
+        font-weight: 700;
+      }
+
+      @media (max-width: 860px) {
+        .hero-top,
+        .grid {
+          grid-template-columns: 1fr;
+        }
+
+        .meta-grid,
+        .stack-grid {
+          grid-template-columns: 1fr;
+        }
+
+        body {
+          padding: 0;
+        }
+
+        .shell {
+          width: min(100%, calc(100% - 24px));
+          margin: 12px auto 24px;
+        }
+
+        .hero {
+          padding: 22px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="shell">
+      <section class="hero">
+        <div class="hero-top">
+          <div>
+            <span class="eyebrow">Debug modu açık</span>
+            <h1>ASJS bir hata yakaladı.</h1>
+            <p>Bu sayfa yalnızca debug modu etkinken gösterilir. Amaç, hatayı kısa özetle görünür kılmak ve asıl teknik ayrıntıları aynı ekranda profesyonel şekilde sunmaktır.</p>
+            <div class="callout">
+              <div class="status-badge"><span class="status-dot"></span> HTTP ${status} · ${errorName}</div>
+              <p class="subtle">${message}</p>
+            </div>
+          </div>
+
+          <article class="panel">
+            <h2 class="headline">Hızlı özet</h2>
+            <ul class="summary-list">
+              <li><strong>İstek:</strong> ${method} ${requestPath}</li>
+              <li><strong>Şablon:</strong> <code>${templatePath}</code></li>
+              <li><strong>İlk çerçeve:</strong> <code>${primaryFrame}</code></li>
+              <li><strong>Zaman:</strong> ${timestamp}</li>
+            </ul>
+          </article>
+        </div>
+
+        <div class="meta-grid">
+          ${environmentItems.map((item) => `
+          <article class="meta-card">
+            <span class="label">${item.label}</span>
+            <span class="value">${item.value}</span>
+          </article>`).join('')}
+        </div>
+
+        <div class="stack-grid">
+          <article class="stack-panel">
+            <h2 class="section-title">Stack trace</h2>
+            <div class="stack">
+              <pre>${stack}</pre>
+            </div>
+            ${cause ? `
+            <details>
+              <summary>Asıl sebep</summary>
+              <div class="stack"><pre>${cause}</pre></div>
+            </details>` : ''}
+          </article>
+
+          <article class="stack-panel">
+            <h2 class="section-title">Muhtemel kontrol listesi</h2>
+            <ul class="tips">
+              ${hintItems.map((item) => `<li><strong>Kontrol:</strong> ${escapeHtml(item)}</li>`).join('')}
+            </ul>
+            <details>
+              <summary>Teknik not</summary>
+              <p class="subtle">Bu görünüm, route zinciri kırıldığında ham Express hata çıktısı yerine daha okunur bir teknik özet verir. Üretim ortamında debug kapalıysa bu ekran gösterilmez.</p>
+            </details>
+          </article>
+        </div>
+      </section>
+    </div>
+  </body>
+</html>`;
+}
+
+function buildPageLocals(req, config, pageData = {}) {
+  const input = pageData && typeof pageData === 'object' ? pageData : {};
+  const status = Number.isInteger(input.status) ? input.status : null;
+  const transition = Object.prototype.hasOwnProperty.call(input, 'transition')
+    ? normalizeTransitionOptions(input.transition, config.transitions)
+    : { ...config.transitions };
+  const pageAsjs = input.asjs && typeof input.asjs === 'object' ? input.asjs : {};
+  const locals = {
+    ...config.locals,
+    ...input
+  };
+
+  delete locals.status;
+  delete locals.transition;
+  delete locals.asjs;
+
+  locals.navItems = Array.isArray(input.navItems) ? input.navItems : config.navItems;
+  locals.currentPath = input.currentPath || req.path;
+  locals.asjs = createAsjsViewModel(pageAsjs, config, { transition });
+
+  return {
+    locals,
+    status
+  };
+}
+
+function setupAsjs(app, options = {}) {
+  const config = createAsjsConfig(options);
+
+  function extendLocals(extraLocals = {}) {
+    if (extraLocals && typeof extraLocals === 'object') {
+      config.locals = {
+        ...config.locals,
+        ...extraLocals
+      };
+    }
+
+    return api;
+  }
+
+  function defineComponents(components = {}) {
+    config.components = {
+      ...config.components,
+      ...normalizeComponentRegistry(components, config.extension)
+    };
+
+    return api;
+  }
+
+  function addHook(name, handler) {
+    registerHook(config.hooks, name, handler);
+    return api;
+  }
+
+  function clearCache() {
+    config.templateCache.clear();
+  }
+
+  function render(res, viewName, pageData = {}) {
+    const renderContext = runSyncHooks(config.hooks, 'beforeRender', {
+      app,
+      config,
+      req: res.req,
+      res,
+      viewName,
+      pageData
+    });
+    const { locals, status } = buildPageLocals(res.req, config, renderContext.pageData);
+
+    if (status) {
+      res.status(status);
+    }
+
+    const output = res.render(viewName, locals);
+
+    runSyncHooks(config.hooks, 'afterRender', {
+      ...renderContext,
+      locals,
+      status
+    });
+
+    return output;
+  }
+
+  function resolvePageData(req, res, next, viewName, pageData) {
+    return runHookChain(config.hooks, 'beforePage', {
+      app,
+      config,
+      req,
+      res,
+      next,
+      viewName,
+      pageData: undefined
+    }).then((beforePageContext) => {
+      return Promise.resolve(
+        typeof pageData === 'function'
+          ? pageData(beforePageContext.req, beforePageContext.res, beforePageContext.next)
+          : pageData
+      ).then((resolvedPageData) => {
+        return runHookChain(config.hooks, 'afterPage', {
+          ...beforePageContext,
+          pageData: resolvedPageData
+        });
+      });
+    });
+  }
+
+  function page(viewName, pageData) {
+    return function asjsPageHandler(req, res, next) {
+      resolvePageData(req, res, next, viewName, pageData)
+        .then((context) => {
+          render(res, viewName, context.pageData || {});
+        })
+        .catch(next);
+    };
+  }
+
+  function notFound(viewName, pageData) {
+    return function asjsNotFoundHandler(req, res, next) {
+      if (res.headersSent) {
+        next();
+        return;
+      }
+
+      resolvePageData(req, res, next, viewName, pageData)
+        .then((context) => {
+          render(res, viewName, {
+            ...(context.pageData || {}),
+            status: 404
+          });
+        })
+        .catch(next);
+    };
+  }
+
+  function errors() {
+    return function asjsErrorHandler(error, req, res, next) {
+      if (res.headersSent) {
+        next(error);
+        return;
+      }
+
+      const status = Number(error.status || 500);
+
+      if (config.debug) {
+        res.status(status).send(renderDebugErrorPage(error, {
+          packageVersion: config.packageVersion,
+          status,
+          requestPath: req.originalUrl || req.url,
+          method: req.method
+        }));
+        return;
+      }
+
+      res.status(status).send(status === 404 ? 'Sayfa bulunamadi' : 'Sunucu hatasi');
+    };
+  }
+
+  const api = {
+    app,
+    config,
+    clearCache,
+    express,
+    render,
+    page,
+    route: page,
+    notFound,
+    errors,
+    renderDebugErrorPage,
+    packagePaths: config.packagePaths,
+    extendLocals,
+    defineComponents,
+    addHook,
+    use(plugin) {
+      applyAsjsPlugin(plugin, api);
+      return api;
+    }
+  };
+
+  config.plugins.forEach((plugin) => {
+    api.use(plugin);
+  });
+
+  app.engine(config.extension, createAsjsEngine(config));
+  app.set('view engine', config.extension);
+  app.set('views', config.viewsDir);
+
+  if (config.serveClientAssets) {
+    app.use(config.assetMountPath, express.static(config.packagePaths.clientDir, {
+      fallthrough: true,
+      immutable: !config.debug,
+      index: false,
+      maxAge: config.debug ? 0 : '1h'
+    }));
+  }
+
+  if (config.publicDir) {
+    app.use(express.static(config.publicDir));
+  }
+
+  app.locals.asjs = createAsjsViewModel({}, config);
+
+  return api;
+}
+
+module.exports = {
+  createAsjsConfig,
+  createAsjsEngine,
+  escapeHtml,
+  getAsjsPackagePaths,
+  renderClientTags,
+  renderDebugErrorPage,
+  validateComponentProps,
+  setupAsjs
+};