@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/computed.js

@@ -0,0 +1,382 @@
+let activeEffect = null;
+const effectStack = [], refDeps = new WeakMap;
+export function ref(initialValue) {
+  let value = initialValue;
+  const subscribers = new Set, refObj = {
+    get value() {
+      if (activeEffect) {
+        let deps = refDeps.get(refObj);
+        if (!deps) {
+          deps = new Set;
+          refDeps.set(refObj, deps);
+        }
+        deps.add(activeEffect);
+      }
+      return value;
+    },
+    set value(newValue) {
+      if (!Object.is(value, newValue)) {
+        value = newValue;
+        subscribers.forEach((callback) => callback(newValue));
+        const deps = refDeps.get(refObj);
+        if (deps)
+          deps.forEach((effect) => effect());
+      }
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    peek() {
+      return value;
+    }
+  };
+  return refObj;
+}
+export function isRef(value) {
+  return value !== null && typeof value === "object" && "value" in value && "subscribe" in value && "peek" in value;
+}
+export function unref(value) {
+  return isRef(value) ? value.value : value;
+}
+export function toRefs(obj) {
+  const result = {};
+  for (const key in obj)
+    if (Object.prototype.hasOwnProperty.call(obj, key))
+      result[key] = ref(obj[key]);
+  return result;
+}
+export function shallowRef(initialValue) {
+  return ref(initialValue);
+}
+export function computed(getterOrOptions) {
+  const isFunction = typeof getterOrOptions === "function", getter = isFunction ? getterOrOptions : getterOrOptions.get, setter = isFunction ? void 0 : getterOrOptions.set, equals = isFunction ? Object.is : getterOrOptions.equals || Object.is;
+  let cachedValue, dirty = !0;
+  const deps = new Set, subscribers = new Set, effect = () => {
+    dirty = !0;
+    if (subscribers.size > 0) {
+      const newValue = computedRef.value;
+      subscribers.forEach((callback) => callback(newValue));
+    }
+  };
+  function calculate() {
+    deps.clear();
+    const previousEffect = activeEffect;
+    activeEffect = effect;
+    effectStack.push(effect);
+    try {
+      return getter();
+    } finally {
+      effectStack.pop();
+      activeEffect = previousEffect;
+    }
+  }
+  const computedRef = {
+    get value() {
+      if (activeEffect) {
+        let computedDeps = refDeps.get(computedRef);
+        if (!computedDeps) {
+          computedDeps = new Set;
+          refDeps.set(computedRef, computedDeps);
+        }
+        computedDeps.add(activeEffect);
+      }
+      if (dirty) {
+        const newValue = calculate();
+        if (!equals(cachedValue, newValue))
+          cachedValue = newValue;
+        dirty = !1;
+      }
+      return cachedValue;
+    },
+    set value(newValue) {
+      if (setter)
+        setter(newValue);
+      else
+        console.warn("Computed property is readonly");
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    peek() {
+      if (dirty) {
+        cachedValue = getter();
+        dirty = !1;
+      }
+      return cachedValue;
+    },
+    invalidate() {
+      dirty = !0;
+    },
+    get dirty() {
+      return dirty;
+    },
+    get deps() {
+      return deps;
+    }
+  };
+  return computedRef;
+}
+export function watch(source, callback, options = {}) {
+  const { immediate = !1, deep = !1, flush = "pre", once = !1 } = options;
+  let oldValue, isActive = !0, isPaused = !1;
+  const getValue = () => {
+    if (isRef(source))
+      return deep ? deepClone(source.value) : source.value;
+    return source();
+  }, run = () => {
+    if (!isActive || isPaused)
+      return;
+    const newValue = getValue();
+    if (oldValue !== void 0 && Object.is(oldValue, newValue) && !deep)
+      return;
+    const executeCallback = () => {
+      callback(newValue, oldValue);
+      oldValue = deep ? deepClone(newValue) : newValue;
+      if (once)
+        stop();
+    };
+    if (flush === "sync")
+      executeCallback();
+    else if (flush === "post")
+      queueMicrotask(executeCallback);
+    else
+      Promise.resolve().then(executeCallback);
+  };
+  let unsubscribe = null;
+  if (isRef(source))
+    unsubscribe = source.subscribe(() => run());
+  else
+    unsubscribe = computed(source).subscribe(() => run());
+  if (immediate) {
+    oldValue = void 0;
+    run();
+  } else
+    oldValue = getValue();
+  const stop = () => {
+    isActive = !1;
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function watchMultiple(sources, callback, options = {}) {
+  const { immediate = !1, once = !1 } = options;
+  let oldValues = sources.map((s) => isRef(s) ? s.value : void 0), isActive = !0, isPaused = !1;
+  const run = () => {
+    if (!isActive || isPaused)
+      return;
+    const newValues = sources.map((s) => isRef(s) ? s.value : void 0);
+    callback(newValues, oldValues);
+    oldValues = [...newValues];
+    if (once)
+      stop();
+  }, unsubscribes = sources.map((source) => {
+    if (isRef(source))
+      return source.subscribe(() => run());
+    return () => {};
+  });
+  if (immediate)
+    run();
+  const stop = () => {
+    isActive = !1;
+    unsubscribes.forEach((unsub) => unsub());
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function watchEffect(effect, options = {}) {
+  const { flush = "pre" } = options;
+  let cleanup, isActive = !0, isPaused = !1;
+  const run = () => {
+    if (!isActive || isPaused)
+      return;
+    if (cleanup)
+      cleanup();
+    const previousEffect = activeEffect;
+    activeEffect = run;
+    effectStack.push(run);
+    try {
+      cleanup = effect();
+    } finally {
+      effectStack.pop();
+      activeEffect = previousEffect;
+    }
+  };
+  if (flush === "sync")
+    run();
+  else if (flush === "post")
+    queueMicrotask(run);
+  else
+    Promise.resolve().then(run);
+  const stop = () => {
+    isActive = !1;
+    if (cleanup)
+      cleanup();
+  };
+  stop.pause = () => {
+    isPaused = !0;
+  };
+  stop.resume = () => {
+    isPaused = !1;
+  };
+  return stop;
+}
+export function processComputedDirectives(template, context = {}, _filePath) {
+  const computedRegex = /@computed\s*\(\s*(\w+)\s*,\s*(.+?)\s*\)/gi;
+  return template.replace(computedRegex, (_, name, expression) => {
+    try {
+      const value = Function(...Object.keys(context), `return ${expression}`)(...Object.values(context));
+      context[name] = value;
+      return `<!-- computed: ${name} = ${value} -->`;
+    } catch (error) {
+      return `<!-- computed error: ${name} - ${error} -->`;
+    }
+  });
+}
+export function processWatchDirectives(template, _context = {}, _filePath) {
+  const watchRegex = /@watch\s*\(\s*(\w+)\s*\)\s*([\s\S]*?)@endwatch/gi;
+  return template.replace(watchRegex, (_, source, handler) => {
+    return `
+      <script data-watch="${`watch-${Math.random().toString(36).substring(2, 9)}`}">
+        (function() {
+          // Watch implementation for ${source}
+          const handler = ${handler.trim()};
+          if (window.__stxState && window.__stxState['${source}']) {
+            window.__stxState['${source}'].subscribe(function(newValue) {
+              handler(newValue);
+            });
+          }
+        })();
+      </script>
+    `;
+  });
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => deepClone(item));
+  if (value instanceof Date)
+    return new Date(value.getTime());
+  if (value instanceof Map) {
+    const map = new Map;
+    value.forEach((v, k) => map.set(deepClone(k), deepClone(v)));
+    return map;
+  }
+  if (value instanceof Set) {
+    const set = new Set;
+    value.forEach((v) => set.add(deepClone(v)));
+    return set;
+  }
+  const cloned = {};
+  for (const key in value)
+    if (Object.prototype.hasOwnProperty.call(value, key))
+      cloned[key] = deepClone(value[key]);
+  return cloned;
+}
+export function debouncedComputed(getter, delay = 100) {
+  const result = ref(getter());
+  let timeoutId = null;
+  const debouncedUpdate = () => {
+    if (timeoutId)
+      clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      result.value = getter();
+    }, delay);
+  };
+  computed(getter).subscribe(() => debouncedUpdate());
+  return {
+    get value() {
+      return result.value;
+    },
+    set value(_) {
+      console.warn("Debounced computed is readonly");
+    },
+    subscribe: result.subscribe,
+    peek: result.peek,
+    invalidate() {
+      debouncedUpdate();
+    },
+    get dirty() {
+      return !1;
+    },
+    get deps() {
+      return new Set;
+    }
+  };
+}
+export function throttledComputed(getter, limit = 100) {
+  const result = ref(getter());
+  let lastRun = 0;
+  const throttledUpdate = () => {
+    const now = Date.now();
+    if (now - lastRun >= limit) {
+      lastRun = now;
+      result.value = getter();
+    }
+  };
+  computed(getter).subscribe(() => throttledUpdate());
+  return {
+    get value() {
+      return result.value;
+    },
+    set value(_) {
+      console.warn("Throttled computed is readonly");
+    },
+    subscribe: result.subscribe,
+    peek: result.peek,
+    invalidate() {
+      throttledUpdate();
+    },
+    get dirty() {
+      return !1;
+    },
+    get deps() {
+      return new Set;
+    }
+  };
+}
+
+export {
+  ref as stxRef,
+  computed as stxComputed,
+  watch as stxWatch,
+  watchMultiple as stxWatchMultiple,
+  watchEffect as stxWatchEffect,
+  isRef as stxIsRef,
+  unref as stxUnref,
+  toRefs as stxToRefs,
+  shallowRef as stxShallowRef,
+  debouncedComputed as stxDebouncedComputed,
+  throttledComputed as stxThrottledComputed
+};
+export default {
+  ref,
+  computed,
+  watch,
+  watchMultiple,
+  watchEffect,
+  isRef,
+  unref,
+  toRefs,
+  shallowRef,
+  debouncedComputed,
+  throttledComputed,
+  processComputedDirectives,
+  processWatchDirectives
+};

package/dist/conditionals.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Module for processing conditional directives (@if, @elseif, @else, @unless)
+ *
+ * Regex Pattern Reference:
+ * ========================
+ *
+ * NESTED_PARENS_PATTERN: `(?:[^()]|\([^()]*\))*`
+ *   - Matches content with one level of nested parentheses
+ *   - `[^()]` - Match any character except parentheses
+ *   - `\([^()]*\)` - OR match balanced parentheses (one level deep)
+ *   - Used in: @switch, @case, @if expressions to handle function calls
+ *   - Example matches: `user.role`, `getRole()`, `check(a, b)`
+ *   - Limitation: Only handles ONE level of nesting. `fn(a(b))` won't work correctly.
+ *
+ * DIRECTIVE_WITH_CONTENT: `@directive\s*\(EXPR\)([\s\S]*?)@enddirective`
+ *   - `\s*` - Optional whitespace after directive name
+ *   - `\(EXPR\)` - Parenthesized expression
+ *   - `[\s\S]*?` - Non-greedy match of ANY content (including newlines)
+ *   - `?` makes it non-greedy to match shortest possible content
+ *
+ * IF_ELSEIF_ELSE: Complex multi-branch matching
+ *   - Processes from inside-out to handle nesting
+ *   - Each @elseif/@else creates a branch in the condition chain
+ */
+/**
+ * Process switch statements (@switch, @case, @default)
+ *
+ * Uses the parser module for proper handling of:
+ * - Nested parentheses in expressions (e.g., @switch(fn(a, fn(b))))
+ * - Nested @switch blocks
+ * - @break directives
+ */
+export declare function processSwitchStatements(template: string, context: Record<string, any>, _filePath: string): string;
+export declare function processConditionals(template: string, context: Record<string, any>, filePath: string): string;
+/**
+ * Process @auth and permissions directives
+ *
+ * @see Authentication Directive Documentation above for required context shapes
+ */
+export declare function processAuthDirectives(template: string, context: Record<string, any>): string;
+/**
+ * Process @isset and @empty directives
+ */
+export declare function processIssetEmptyDirectives(template: string, context: Record<string, any>, _filePath?: string): string;
+/**
+ * Process @env directive to conditionally render content based on environment
+ */
+export declare function processEnvDirective(template: string, _context: Record<string, any>, _filePath?: string): string;