jskelet 0.5.5 → 0.6.1

package/types/client/swap.d.ts

@@ -0,0 +1,46 @@
+export type SwapOptions = {
+    /**
+     * Varsayılan `GET`.
+     */
+    method?: string;
+    body?: BodyInit | null;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    /**
+     * `true` → adres çubuğu `url` ile güncellenir.
+     */
+    history?: boolean;
+    /**
+     * Varsayılan `replace`.
+     */
+    mode?: "replace" | "append";
+};
+/**
+ * @typedef {object} SwapOptions
+ * @property {string} [method] Varsayılan `GET`.
+ * @property {BodyInit | null} [body]
+ * @property {Record<string, string>} [headers]
+ * @property {AbortSignal} [signal]
+ * @property {boolean} [history] `true` → adres çubuğu `url` ile güncellenir.
+ * @property {"replace" | "append"} [mode] Varsayılan `replace`.
+ */
+/**
+ * @param {Element | string} target Takas edilecek bölge.
+ * @param {string} url Parçayı döndüren uç.
+ * @param {SwapOptions} [options]
+ * @returns {Promise<boolean>} Başarılıysa `true`; hata durumunda mevcut
+ *   içerik korunur ve `false` döner.
+ */
+export declare function swap(target: Element | string, url: string, options?: SwapOptions): Promise<boolean>;
+/**
+ * `data-swap` taşıyan bağlantı ve butonları otomatik bağlar.
+ *
+ *   <a href="/_fragment/rows?page=2" data-swap="#rows" data-swap-history>…</a>
+ *
+ * Tek bir delege dinleyici: sonradan DOM'a giren bağlantılar da çalışır ve
+ * her takastan sonra yeniden bağlama gerekmez.
+ *
+ * @param {ParentNode} [root]
+ * @returns {() => void} Dinleyiciyi söken fonksiyon.
+ */
+export declare function startSwapLinks(root?: ParentNode): () => void;

package/types/compile/codegen.d.ts

@@ -0,0 +1,32 @@
+export type AstNode = import('./parse.js').AstNode;
+export type AttrNode = import('./parse.js').AttrNode;
+/**
+ * @typedef {import('./parse.js').AstNode} AstNode
+ * @typedef {import('./parse.js').AttrNode} AttrNode
+ */
+/**
+ * @param {AstNode[]} ast
+ * @param {{ viewId: string, file?: string, knownComponents?: Set<string> }} options
+ * @returns {{ code: string, includes: string[], components: string[] }}
+ */
+export declare function codegen(ast: AstNode[], options: {
+    viewId: string;
+    file?: string;
+    knownComponents?: Set<string>;
+}): {
+    code: string;
+    includes: string[];
+    components: string[];
+};
+/**
+ * Include yolunu view id'ye çevir (uzantısız, `/` ayırıcılı).
+ * @param {string} includePath
+ * @returns {string}
+ */
+export declare function normalizeIncludeId(includePath: string): string;
+/**
+ * `market-hero` / `MarketHero` → `MarketHero`
+ * @param {string} name
+ * @returns {string}
+ */
+export declare function toPascalCase(name: string): string;

package/types/compile/compile-all.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @param {{ quiet?: boolean }} [options]
+ * @returns {Promise<{ count: number, manifest: Record<string, string>, outDir: string }>}
+ */
+export declare function compileAll(config: {
+    root: string;
+    dirs: Record<string, string>;
+}, _options?: {}): Promise<{
+    count: number;
+    manifest: Record<string, string>;
+    outDir: string;
+}>;
+/**
+ * Manifest yoksa veya herhangi bir `.jsk` daha yeniyse yeniden derler.
+ * Dev sunucu restart'ında build watch kaçırmış olsa bile şablonlar güncel kalır.
+ *
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @returns {Promise<{ count: number, rebuilt: boolean }>}
+ */
+export declare function ensureTemplatesCompiled(config: {
+    root: string;
+    dirs: Record<string, string>;
+}): Promise<{
+    count: number;
+    rebuilt: boolean;
+}>;
+/**
+ * Tek kaynak dizgisini derler (birim testleri).
+ * @param {string} source
+ * @param {{ viewId?: string, file?: string, knownComponents?: Set<string> }} [options]
+ * @returns {{ code: string, includes: string[], components: string[] }}
+ */
+export declare function compileSource(source: string, options?: {
+    viewId?: string;
+    file?: string;
+    knownComponents?: Set<string>;
+}): {
+    code: string;
+    includes: string[];
+    components: string[];
+};

package/types/compile/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Şablon derleme hataları. Satır/sütun korunur ki DX overlay ve CLI
+ * çıktısı kaynağa işaret edebilsin.
+ */
+/**
+ * @param {string} source
+ * @param {number} index
+ * @returns {{ line: number, column: number }}
+ */
+export declare function indexToLocation(source: string, index: number): {
+    line: number;
+    column: number;
+};
+export declare class CompileError extends Error {
+    file: string | undefined;
+    line: number | undefined;
+    column: number | undefined;
+    /**
+     * @param {string} message
+     * @param {{ file?: string, source?: string, index?: number,
+     *   line?: number, column?: number }} [opts]
+     */
+    constructor(message: string, opts?: {
+        file?: string;
+        source?: string;
+        index?: number;
+        line?: number;
+        column?: number;
+    });
+}

package/types/compile/expr.d.ts

@@ -0,0 +1,67 @@
+export type LiteralNode = {
+    type: 'Literal';
+    value: string | number | boolean | null;
+    raw: string;
+};
+export type IdentNode = {
+    type: 'Ident';
+    name: string;
+};
+export type MemberNode = {
+    type: 'Member';
+    object: ExprNode;
+    property: string;
+    optional: boolean;
+};
+export type IndexNode = {
+    type: 'Index';
+    object: ExprNode;
+    index: ExprNode;
+    optional: boolean;
+};
+export type UnaryNode = {
+    type: 'Unary';
+    op: '!' | '-';
+    argument: ExprNode;
+};
+export type BinaryNode = {
+    type: 'Binary';
+    op: string;
+    left: ExprNode;
+    right: ExprNode;
+};
+export type CondNode = {
+    type: 'Cond';
+    test: ExprNode;
+    consequent: ExprNode;
+    alternate: ExprNode;
+};
+export type ExprNode = LiteralNode | IdentNode | MemberNode | IndexNode | UnaryNode | BinaryNode | CondNode;
+/**
+ * @param {string} source
+ * @param {number} start
+ * @param {number} end
+ * @param {{ file?: string, templateSource?: string, templateIndex?: number }} [meta]
+ * @returns {ExprNode}
+ */
+export declare function parseExpr(source: string, start?: number, end?: number, meta?: {
+    file?: string;
+    templateSource?: string;
+    templateIndex?: number;
+}): ExprNode;
+/**
+ * İfadeyi JS kaynak metnine çevirir. `locals` içindeki isimler çıplak kalır;
+ * diğerleri `data.` öneki alır.
+ *
+ * @param {ExprNode} node
+ * @param {Set<string>} [locals]
+ * @returns {string}
+ */
+export declare function codegenExpr(node: ExprNode, locals?: Set<string>): string;
+/**
+ * İfadede geçen kök tanımlayıcılar (data alanları / local adayları).
+ * @param {ExprNode} node
+ * @param {Set<string>} [out]
+ * @returns {Set<string>}
+ */
+export declare function collectIdents(node: ExprNode, out?: Set<string>): Set<string>;

package/types/compile/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Build-time `.jsk` derleyici yüzeyi.
+ */
+export { CompileError, indexToLocation } from "./errors.js";
+export { parseExpr, codegenExpr } from "./expr.js";
+export { parseTemplate, isComponentTag } from "./parse.js";
+export { codegen, toPascalCase, normalizeIncludeId } from "./codegen.js";
+export { getViewRoots, getComponentDirs, discoverJskFiles, componentNameFromViewId, collectKnownComponents, toComponentTag, } from "./resolve.js";
+export { scanNamedExports } from "./scan-exports.js";
+export { compileAll, compileSource, ensureTemplatesCompiled } from "./compile-all.js";

package/types/compile/parse.d.ts

@@ -0,0 +1,82 @@
+export type ExprNode = import('./expr.js').ExprNode;
+export type TextNode = {
+    type: 'Text';
+    value: string;
+};
+export type InterpNode = {
+    type: 'Interp';
+    expr: ExprNode;
+    raw: boolean;
+    index: number;
+};
+export type AttrNode = {
+    name: string;
+    value: string | null;
+    expr: ExprNode | null;
+    bound: boolean;
+    boolean: boolean;
+    index: number;
+};
+export type ElementNode = {
+    type: 'Element';
+    name: string;
+    attrs: AttrNode[];
+    children: AstNode[];
+    selfClosing: boolean;
+    index: number;
+};
+export type ComponentNode = {
+    type: 'Component';
+    name: string;
+    attrs: AttrNode[];
+    children: AstNode[];
+    selfClosing: boolean;
+    index: number;
+};
+export type IfNode = {
+    type: 'If';
+    test: ExprNode;
+    consequent: AstNode[];
+    alternate: AstNode[];
+    index: number;
+};
+export type EachNode = {
+    type: 'Each';
+    list: ExprNode;
+    item: string;
+    indexName: string | null;
+    children: AstNode[];
+    index: number;
+};
+export type IncludeNode = {
+    type: 'Include';
+    path: string;
+    index: number;
+};
+export type AstNode = TextNode | InterpNode | ElementNode | ComponentNode | IfNode | EachNode | IncludeNode;
+/**
+ * @typedef {import('./expr.js').ExprNode} ExprNode
+ * @typedef {{ type: 'Text', value: string }} TextNode
+ * @typedef {{ type: 'Interp', expr: ExprNode, raw: boolean, index: number }} InterpNode
+ * @typedef {{ name: string, value: string | null, expr: ExprNode | null, bound: boolean, boolean: boolean, index: number }} AttrNode
+ * @typedef {{ type: 'Element', name: string, attrs: AttrNode[], children: AstNode[], selfClosing: boolean, index: number }} ElementNode
+ * @typedef {{ type: 'Component', name: string, attrs: AttrNode[], children: AstNode[], selfClosing: boolean, index: number }} ComponentNode
+ * @typedef {{ type: 'If', test: ExprNode, consequent: AstNode[], alternate: AstNode[], index: number }} IfNode
+ * @typedef {{ type: 'Each', list: ExprNode, item: string, indexName: string | null, children: AstNode[], index: number }} EachNode
+ * @typedef {{ type: 'Include', path: string, index: number }} IncludeNode
+ * @typedef {TextNode | InterpNode | ElementNode | ComponentNode | IfNode | EachNode | IncludeNode} AstNode
+ */
+/**
+ * @param {string} source
+ * @param {{ file?: string }} [options]
+ * @returns {AstNode[]}
+ */
+export declare function parseTemplate(source: string, options?: {
+    file?: string;
+}): AstNode[];
+/**
+ * PascalCase bileşen mi?
+ * @param {string} name
+ * @returns {boolean}
+ */
+export declare function isComponentTag(name: string): boolean;

package/types/compile/resolve.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Runtime'ın camelCase → PascalCase alias'ı ile aynı kural.
+ * @param {string} name
+ * @returns {string}
+ */
+export declare function toComponentTag(name: string): string;
+/**
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @returns {string[]} Mutlak view kökleri (var olanlar).
+ */
+export declare function getViewRoots(config: {
+    root: string;
+    dirs: Record<string, string>;
+}): string[];
+/**
+ * Bileşen dizinleri: her view kökü altındaki `components/`.
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @returns {string[]}
+ */
+export declare function getComponentDirs(config: {
+    root: string;
+    dirs: Record<string, string>;
+}): string[];
+/**
+ * @param {string[]} viewRoots
+ * @returns {Map<string, string>} viewId → mutlak `.jsk` yolu
+ */
+export declare function discoverJskFiles(viewRoots: string[]): Map<string, string>;
+/**
+ * `components/foo-bar.jsk` → `FooBar`
+ * @param {string} viewId
+ * @returns {string | null}
+ */
+export declare function componentNameFromViewId(viewId: string): string | null;
+/**
+ * Bilinen bileşen adları: JS named export'lar + derlenecek `.jsk` bileşenleri
+ * + yerleşik etiketler.
+ *
+ * JS tarafında dosya adı varsayılmaz; kaynak metinden `export` adları okunur.
+ * Aynı export (veya aynı PascalCase etiket) iki dosyada varsa derleme hatası.
+ *
+ * @param {string[]} componentDirs
+ * @param {Map<string, string>} jskFiles
+ * @returns {Set<string>}
+ */
+export declare function collectKnownComponents(componentDirs: string[], jskFiles: Map<string, string>): Set<string>;

package/types/compile/scan-exports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Kaynak metinden named export adlarını çıkarır — modülü çalıştırmadan.
+ * Compile-time bilinen bileşen listesi için; `default` yok sayılır.
+ */
+/**
+ * @param {string} source
+ * @returns {string[]}
+ */
+export declare function scanNamedExports(source: string): string[];