@mintjamsinc/ichigojs 0.1.8 → 0.1.9

package/dist/types/ichigo/directives/StandardDirectiveName.d.ts

@@ -1,12 +1,25 @@
+/**
+ * Standard directive names used in the framework.
+ */
 export declare enum StandardDirectiveName {
+    /** Conditional rendering directives (if). */
     V_IF = "v-if",
+    /** Conditional rendering directives (else if). */
     V_ELSE_IF = "v-else-if",
+    /** Conditional rendering directives (else). */
     V_ELSE = "v-else",
+    /** Conditional rendering directives (show). */
     V_SHOW = "v-show",
+    /** List rendering directives. */
     V_FOR = "v-for",
+    /** Event handling directives. */
     V_ON = "v-on",
+    /** Attribute binding directives. */
     V_BIND = "v-bind",
+    /** Two-way data binding directives. */
     V_MODEL = "v-model",
+    /** Slot content insertion directives. */
     V_RESIZE = "v-resize",
+    /** Intersection observer directives. */
     V_INTERSECTION = "v-intersection"
 }

package/dist/types/ichigo/directives/VConditionalDirective.d.ts

@@ -4,6 +4,11 @@ import { VConditionalDirectiveContext } from "./VConditionalDirectiveContext";
 import { VDirective } from "./VDirective";
 import { VDirectiveParseContext } from "./VDirectiveParseContext";
 import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Base class for conditional directives such as v-if, v-else-if, and v-else.
+ * This class manages the rendering of the associated virtual node based on the evaluation of the directive's condition.
+ * It also coordinates with other related conditional directives to ensure only one block is rendered at a time.
+ */
 export declare abstract class VConditionalDirective implements VDirective {
     #private;
     /**

package/dist/types/ichigo/directives/VDirectiveParserRegistry.d.ts

@@ -1,5 +1,9 @@
 import { VDirectiveParseContext } from "./VDirectiveParseContext";
 import { VDirectiveParser } from "./VDirectiveParser";
+/**
+ * Registry for managing directive parsers.
+ * This class allows registering, unregistering, and finding directive parsers.
+ */
 export declare class VDirectiveParserRegistry {
     #private;
     /**

package/dist/types/ichigo/directives/VPerformanceDirective.d.ts

@@ -0,0 +1,105 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Configuration options for the v-performance directive.
+ */
+export interface VPerformanceOptions {
+    /**
+     * The type(s) of performance entries to observe.
+     * Can be a single type or an array of types.
+     * Common types: 'mark', 'measure', 'navigation', 'resource', 'paint', 'element', 'largest-contentful-paint', 'layout-shift'
+     */
+    entryTypes?: string | string[];
+    /**
+     * Whether to include buffered entries (entries that occurred before the observer was created).
+     * Default: false
+     */
+    buffered?: boolean;
+}
+/**
+ * Directive for observing performance entries using PerformanceObserver.
+ * The `v-performance` directive allows you to monitor various performance metrics.
+ *
+ * Example usage:
+ *     <div v-performance="handlePerformance">Performance monitoring</div>
+ *     <div v-performance="{ handler: handlePerformance, options: { entryTypes: ['measure', 'mark'], buffered: true } }">
+ *       Advanced monitoring
+ *     </div>
+ *
+ * The handler receives PerformanceObserverEntryList and PerformanceObserver as the first two arguments,
+ * and $ctx as the third:
+ *     handlePerformance(list, observer, $ctx) {
+ *       list.getEntries().forEach(entry => {
+ *         console.log(`${entry.entryType}: ${entry.name} - ${entry.duration}ms`);
+ *       });
+ *     }
+ *
+ * This directive is useful for monitoring application performance, custom metrics,
+ * and identifying performance bottlenecks.
+ */
+export declare class VPerformanceDirective implements VDirective {
+    #private;
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+    /**
+     * @inheritdoc
+     */
+    get vNode(): VNode;
+    /**
+     * @inheritdoc
+     */
+    get needsAnchor(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * @inheritdoc
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
+    /**
+     * @inheritdoc
+     */
+    get onMount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onMounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdate(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdated(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

package/dist/types/ichigo/directives/VResizeDirective.d.ts

@@ -9,6 +9,7 @@ import { VDOMUpdater } from "../VDOMUpdater";
  *
  * Example usage:
  *     <div v-resize="handleResize">Resizable content</div>
+ *     <div v-resize="handleResize" :options.resize="{box: 'border-box'}">Resizable content</div>
  *
  * The handler receives ResizeObserverEntry array as the first argument and $ctx as the second:
  *     handleResize(entries, $ctx) {
@@ -16,6 +17,10 @@ import { VDOMUpdater } from "../VDOMUpdater";
  *       console.log(`Size: ${width}x${height}`);
  *     }
  *
+ * Options can be provided via :options or :options.resize attribute:
+ *     :options="{box: 'border-box'}"
+ *     :options.resize="{box: 'content-box'}"
+ *
  * This directive is useful for responsive layouts, charts, and other components
  * that need to adapt to size changes.
  */

package/dist/types/ichigo/util/ExpressionUtils.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Utility class for analyzing JavaScript expressions to extract variable and function dependencies.
+ */
 export declare class ExpressionUtils {
     /**
      * Extracts variable and function names used in the expression.

package/dist/types/ichigo/util/LogLevel.d.ts

@@ -2,8 +2,12 @@
  * Log level enumeration.
  */
 export declare enum LogLevel {
+    /** Debug level */
     DEBUG = "debug",
+    /** Info level */
     INFO = "info",
+    /** Warning level */
     WARN = "warn",
+    /** Error level */
     ERROR = "error"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "ichigo.js - Simple and intuitive reactive framework. Lightweight, fast, and user-friendly virtual DOM library",
   "main": "./dist/ichigo.umd.js",
   "module": "./dist/ichigo.esm.js",