vsn 1.0.1 → 1.0.3

package/dist/plugins/microdata.d.ts

@@ -0,0 +1,481 @@
+declare class Scope {
+    readonly parent?: Scope | undefined;
+    private data;
+    private root;
+    private listeners;
+    private anyListeners;
+    isEachItem: boolean;
+    constructor(parent?: Scope | undefined);
+    createChild(): Scope;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    hasKey(path: string): boolean;
+    getPath(path: string): any;
+    setPath(path: string, value: any): void;
+    on(path: string, handler: () => void): void;
+    off(path: string, handler: () => void): void;
+    onAny(handler: () => void): void;
+    offAny(handler: () => void): void;
+    private emitChange;
+    private resolveScope;
+    private getLocalPathValue;
+    private findNearestScopeWithKey;
+}
+
+interface ExecutionContext {
+    scope: {
+        getPath(key: string): any;
+        setPath?(key: string, value: any): void;
+        hasKey?(key: string): boolean;
+        createChild?(): ExecutionContext["scope"];
+    } | undefined;
+    rootScope: ExecutionContext["scope"];
+    globals?: Record<string, any>;
+    element?: Element;
+    returnValue?: any;
+    returning?: boolean;
+    breaking?: boolean;
+    continuing?: boolean;
+}
+interface CFSNode {
+    type: string;
+    prepare(context: ExecutionContext): Promise<void>;
+    evaluate(context: ExecutionContext): any;
+}
+declare abstract class BaseNode implements CFSNode {
+    type: string;
+    constructor(type: string);
+    prepare(_context: ExecutionContext): Promise<void>;
+    evaluate(_context: ExecutionContext): any;
+}
+declare class BlockNode extends BaseNode {
+    statements: CFSNode[];
+    constructor(statements: CFSNode[]);
+    evaluate(context: ExecutionContext): any;
+}
+declare class AssignmentNode extends BaseNode {
+    target: AssignmentTarget;
+    value: ExpressionNode;
+    operator: "=" | "+=" | "-=" | "*=" | "/=" | "++" | "--";
+    prefix: boolean;
+    constructor(target: AssignmentTarget, value: ExpressionNode, operator?: "=" | "+=" | "-=" | "*=" | "/=" | "++" | "--", prefix?: boolean);
+    evaluate(context: ExecutionContext): any;
+    private applyCompoundAssignment;
+    private applyIncrement;
+    private resolveAssignmentTarget;
+    private resolveIndexPath;
+    private resolveTargetPath;
+    private assignTarget;
+    private assignDirectiveTarget;
+}
+declare class FunctionExpression extends BaseNode {
+    params: FunctionParam[];
+    body: BlockNode;
+    isAsync: boolean;
+    constructor(params: FunctionParam[], body: BlockNode, isAsync?: boolean);
+    evaluate(context: ExecutionContext): any;
+    private applyParams;
+    private restoreParams;
+}
+interface DeclarationFlags {
+    important?: boolean;
+    trusted?: boolean;
+    debounce?: boolean;
+    [key: string]: boolean | undefined;
+}
+interface DeclarationFlagArgs {
+    debounce?: number;
+    [key: string]: any;
+}
+interface BehaviorFlags {
+    [key: string]: boolean | undefined;
+}
+interface BehaviorFlagArgs {
+    [key: string]: any;
+}
+declare class DeclarationNode extends BaseNode {
+    target: DeclarationTarget;
+    operator: ":" | ":=" | ":<" | ":>";
+    value: ExpressionNode;
+    flags: DeclarationFlags;
+    flagArgs: DeclarationFlagArgs;
+    constructor(target: DeclarationTarget, operator: ":" | ":=" | ":<" | ":>", value: ExpressionNode, flags: DeclarationFlags, flagArgs: DeclarationFlagArgs);
+}
+type ExpressionNode = AssignmentNode | IdentifierExpression | LiteralExpression | TemplateExpression | UnaryExpression | BinaryExpression | MemberExpression | CallExpression | ArrayExpression | ObjectExpression | IndexExpression | FunctionExpression | AwaitExpression | TernaryExpression | DirectiveExpression | QueryExpression;
+type DeclarationTarget = IdentifierExpression | DirectiveExpression;
+type AssignmentTarget = IdentifierExpression | MemberExpression | IndexExpression | DirectiveExpression | ArrayPattern | ObjectPattern;
+type FunctionParam = {
+    name: string;
+    defaultValue?: ExpressionNode;
+    rest?: boolean;
+};
+type PatternNode = IdentifierExpression | ArrayPattern | ObjectPattern;
+declare class IdentifierExpression extends BaseNode {
+    name: string;
+    constructor(name: string);
+    evaluate(context: ExecutionContext): any;
+}
+declare class SpreadElement extends BaseNode {
+    value: ExpressionNode;
+    constructor(value: ExpressionNode);
+}
+declare class RestElement extends BaseNode {
+    target: IdentifierExpression;
+    constructor(target: IdentifierExpression);
+}
+type ArrayPatternElement = PatternNode | RestElement | null;
+declare class ArrayPattern extends BaseNode {
+    elements: ArrayPatternElement[];
+    constructor(elements: ArrayPatternElement[]);
+}
+type ObjectPatternEntry = {
+    key: string;
+    target: PatternNode;
+} | {
+    rest: IdentifierExpression;
+};
+declare class ObjectPattern extends BaseNode {
+    entries: ObjectPatternEntry[];
+    constructor(entries: ObjectPatternEntry[]);
+}
+declare class LiteralExpression extends BaseNode {
+    value: string | number | boolean | null;
+    constructor(value: string | number | boolean | null);
+    evaluate(): any;
+}
+declare class TemplateExpression extends BaseNode {
+    parts: ExpressionNode[];
+    constructor(parts: ExpressionNode[]);
+    evaluate(context: ExecutionContext): any;
+}
+declare class UnaryExpression extends BaseNode {
+    operator: string;
+    argument: ExpressionNode;
+    constructor(operator: string, argument: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
+}
+declare class BinaryExpression extends BaseNode {
+    operator: string;
+    left: ExpressionNode;
+    right: ExpressionNode;
+    constructor(operator: string, left: ExpressionNode, right: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
+}
+declare class TernaryExpression extends BaseNode {
+    test: ExpressionNode;
+    consequent: ExpressionNode;
+    alternate: ExpressionNode;
+    constructor(test: ExpressionNode, consequent: ExpressionNode, alternate: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
+}
+declare class MemberExpression extends BaseNode {
+    target: ExpressionNode;
+    property: string;
+    optional: boolean;
+    constructor(target: ExpressionNode, property: string, optional?: boolean);
+    evaluate(context: ExecutionContext): any;
+    resolve(context: ExecutionContext): {
+        value: any;
+        target?: any;
+        optional?: boolean;
+    } | undefined | Promise<{
+        value: any;
+        target?: any;
+        optional?: boolean;
+    } | undefined>;
+    getIdentifierPath(): {
+        path: string;
+        root: string;
+    } | undefined;
+    private getTargetIdentifierPath;
+    private resolveFromScope;
+    private resolveFromGlobals;
+    private getTargetPath;
+}
+declare class CallExpression extends BaseNode {
+    callee: ExpressionNode;
+    args: ExpressionNode[];
+    constructor(callee: ExpressionNode, args: ExpressionNode[]);
+    evaluate(context: ExecutionContext): any;
+    private resolveCallee;
+}
+type ArrayElement = ExpressionNode | SpreadElement;
+declare class ArrayExpression extends BaseNode {
+    elements: ArrayElement[];
+    constructor(elements: ArrayElement[]);
+    evaluate(context: ExecutionContext): any;
+}
+type ObjectEntry = {
+    key: string;
+    value: ExpressionNode;
+    computed?: false;
+} | {
+    keyExpr: ExpressionNode;
+    value: ExpressionNode;
+    computed: true;
+} | {
+    spread: ExpressionNode;
+};
+declare class ObjectExpression extends BaseNode {
+    entries: ObjectEntry[];
+    constructor(entries: ObjectEntry[]);
+    evaluate(context: ExecutionContext): any;
+}
+declare class IndexExpression extends BaseNode {
+    target: ExpressionNode;
+    index: ExpressionNode;
+    constructor(target: ExpressionNode, index: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
+    private normalizeIndexKey;
+}
+declare class DirectiveExpression extends BaseNode {
+    kind: "attr" | "style";
+    name: string;
+    constructor(kind: "attr" | "style", name: string);
+    evaluate(context: ExecutionContext): any;
+}
+declare class AwaitExpression extends BaseNode {
+    argument: ExpressionNode;
+    constructor(argument: ExpressionNode);
+    evaluate(context: ExecutionContext): any;
+}
+declare class QueryExpression extends BaseNode {
+    direction: "self" | "descendant" | "ancestor";
+    selector: string;
+    constructor(direction: "self" | "descendant" | "ancestor", selector: string);
+    evaluate(context: ExecutionContext): any;
+}
+
+interface RegisteredBehavior {
+    id: number;
+    hash: string;
+    selector: string;
+    rootSelector: string;
+    parentSelector?: string;
+    specificity: number;
+    order: number;
+    construct?: BlockNode;
+    destruct?: BlockNode;
+    onBlocks: {
+        event: string;
+        body: BlockNode;
+        flags: DeclarationFlags;
+        flagArgs: DeclarationFlagArgs;
+        args: string[];
+    }[];
+    declarations: DeclarationNode[];
+    functions: FunctionBinding[];
+    flags: BehaviorFlags;
+    flagArgs: BehaviorFlagArgs;
+}
+type FunctionBinding = {
+    name: string;
+    params: FunctionParam[];
+    body: BlockNode;
+};
+type AttributeHandler = {
+    id: string;
+    match: (name: string) => boolean;
+    handle: (element: Element, name: string, value: string, scope: Scope) => boolean | void;
+};
+type FlagApplyContext = {
+    name: string;
+    args: any;
+    element: Element;
+    scope: Scope;
+    declaration: DeclarationNode;
+};
+type FlagHandler = {
+    onApply?: (context: FlagApplyContext) => void;
+    transformValue?: (context: FlagApplyContext, value: any) => any;
+    onEventBind?: (context: EventFlagContext) => EventBindPatch | void;
+    onEventBefore?: (context: EventFlagContext) => boolean | void;
+    onEventAfter?: (context: EventFlagContext) => void;
+    transformEventArgs?: (context: EventFlagContext, args: any[]) => any[];
+};
+type BehaviorModifierHandler = {
+    onBind?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onConstruct?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onDestruct?: (context: BehaviorModifierContext) => void | Promise<void>;
+    onUnbind?: (context: BehaviorModifierContext) => void | Promise<void>;
+};
+type BehaviorModifierContext = {
+    name: string;
+    args: any;
+    element: Element;
+    scope: Scope;
+    rootScope: Scope | undefined;
+    behavior: RegisteredBehavior;
+    engine: Engine;
+};
+type EventBindPatch = {
+    listenerTarget?: EventTarget;
+    options?: AddEventListenerOptions;
+    debounceMs?: number;
+};
+type EventFlagContext = {
+    name: string;
+    args: any;
+    element: Element;
+    scope: Scope;
+    rootScope: Scope | undefined;
+    event: Event | undefined;
+    engine: Engine;
+};
+type EngineOptions = {
+    diagnostics?: boolean;
+    logger?: Partial<Pick<Console, "info" | "warn">>;
+};
+declare class Engine {
+    private static activeEngines;
+    private scopes;
+    private bindBindings;
+    private ifBindings;
+    private showBindings;
+    private htmlBindings;
+    private getBindings;
+    private eachBindings;
+    private lifecycleBindings;
+    private behaviorRegistry;
+    private behaviorRegistryHashes;
+    private behaviorBindings;
+    private behaviorListeners;
+    private behaviorId;
+    private codeCache;
+    private behaviorCache;
+    private observer;
+    private attributeHandlers;
+    private globals;
+    private importantFlags;
+    private inlineDeclarations;
+    private flagHandlers;
+    private behaviorModifiers;
+    private pendingAdded;
+    private pendingRemoved;
+    private pendingUpdated;
+    private observerFlush?;
+    private ignoredAdded;
+    private diagnostics;
+    private logger;
+    private pendingUses;
+    private pendingAutoBindToScope;
+    private scopeWatchers;
+    private executionStack;
+    private groupProxyCache;
+    constructor(options?: EngineOptions);
+    private getGroupTargetScope;
+    private getGroupProxy;
+    mount(root: HTMLElement): Promise<void>;
+    unmount(element: Element): void;
+    registerBehaviors(source: string): void;
+    registerGlobal(name: string, value: any): void;
+    registerGlobals(values: Record<string, any>): void;
+    registerFlag(name: string, handler?: FlagHandler): void;
+    registerBehaviorModifier(name: string, handler?: BehaviorModifierHandler): void;
+    getRegistryStats(): {
+        behaviorCount: number;
+        behaviorCacheSize: number;
+    };
+    registerAttributeHandler(handler: AttributeHandler): void;
+    private resolveGlobalPath;
+    private waitForUses;
+    private waitForUseGlobal;
+    getScope(element: Element, parentScope?: Scope): Scope;
+    evaluate(element: Element): void;
+    private attachObserver;
+    private disconnectObserver;
+    private flushObserverQueue;
+    private handleRemovedNode;
+    private handleAddedNode;
+    private handleUpdatedNode;
+    private applyBehaviors;
+    private reapplyBehaviorsForElement;
+    private applyBehaviorForElement;
+    private unbindBehaviorForElement;
+    private runBehaviorDestruct;
+    private attachAttributes;
+    private setLifecycle;
+    private runConstruct;
+    private runDestruct;
+    private parseEachExpression;
+    private renderEach;
+    private attachBindInputHandler;
+    private parseBindDirection;
+    private resolveBindConfig;
+    private isFormControl;
+    private hasScopeValue;
+    private hasElementValue;
+    private coerceInt;
+    private coerceFloat;
+    private isInEachScope;
+    private flushAutoBindQueue;
+    private hasVsnAttributes;
+    private markInlineDeclaration;
+    private isInlineDeclaration;
+    private findParentScope;
+    private watch;
+    private watchWithDebounce;
+    private watchAllScopes;
+    private trackScopeWatcher;
+    private cleanupScopeWatchers;
+    private cleanupBehaviorListeners;
+    private parseOnAttribute;
+    private parseInlineFlags;
+    private parseInlineFlagArg;
+    private describeElement;
+    private logDiagnostic;
+    private emitError;
+    private emitUseError;
+    private attachOnHandler;
+    private attachBehaviorOnHandler;
+    private attachGetHandler;
+    private getEventBindingConfig;
+    private applyEventFlagBefore;
+    private applyEventFlagAfter;
+    private applyEventFlagArgTransforms;
+    private matchesKeyFlag;
+    private withExecutionElement;
+    getCurrentElement(): Element | undefined;
+    private execute;
+    private executeBlock;
+    private safeExecute;
+    private safeExecuteBlock;
+    private collectBehavior;
+    private collectNestedBehaviors;
+    private computeSpecificity;
+    private getBehaviorRootScope;
+    private getImportantKey;
+    private isImportant;
+    private markImportant;
+    private extractLifecycle;
+    private extractOnBlocks;
+    private extractDeclarations;
+    private extractFunctionDeclarations;
+    private getCachedBehavior;
+    private hashBehavior;
+    private normalizeNode;
+    private hashString;
+    private applyBehaviorFunctions;
+    private applyBehaviorFunction;
+    private applyFunctionParams;
+    private restoreFunctionParams;
+    private applyBehaviorDeclarations;
+    private applyBehaviorDeclaration;
+    private applyCustomFlags;
+    private applyCustomFlagTransforms;
+    private applyBehaviorModifierHook;
+    private behaviorHasModifierHooks;
+    private applyDirectiveFromScope;
+    private applyDirectiveFromExpression;
+    private applyDirectiveToScope;
+    private applyCheckedBindingToScope;
+    private applyValueBindingToScope;
+    private setDirectiveValue;
+    private getDirectiveValue;
+    private handleTrustedHtml;
+    private registerDefaultAttributeHandlers;
+}
+
+declare function registerMicrodata(engine: Engine): void;
+
+export { registerMicrodata as default, registerMicrodata };

package/dist/plugins/microdata.js

@@ -0,0 +1,178 @@
+// src/plugins/microdata.ts
+var META_TYPE = "@type";
+var META_ID = "@id";
+function registerMicrodata(engine) {
+  engine.registerBehaviorModifier("microdata", {
+    onBind: ({ element, scope, args }) => {
+      const options = normalizeOptions(args);
+      const root = resolveItemscopeRoot(element);
+      if (!root) {
+        return;
+      }
+      const data = extractMicrodata(root, options);
+      applyMicrodataToScope(scope, data, options);
+    }
+  });
+  engine.registerGlobal("microdata", (target, maybeOptions) => {
+    const options = normalizeOptions(
+      isPlainObject(target) ? target : maybeOptions
+    );
+    const root = resolveTargetElement(engine, target);
+    if (!root) {
+      return void 0;
+    }
+    const data = extractMicrodata(resolveItemscopeRoot(root) ?? root, options);
+    if (typeof target === "string" && !isPlainObject(maybeOptions)) {
+      return data[target];
+    }
+    return data;
+  });
+}
+var microdata_default = registerMicrodata;
+var globals = globalThis;
+var plugins = globals.VSNPlugins ?? {};
+plugins.microdata = (instance) => registerMicrodata(instance);
+globals.VSNPlugins = plugins;
+var autoEngine = globals.VSNEngine;
+if (autoEngine && typeof autoEngine.registerBehaviorModifier === "function") {
+  registerMicrodata(autoEngine);
+}
+function normalizeOptions(value) {
+  if (!value) {
+    return {};
+  }
+  if (typeof value === "string") {
+    return { key: value };
+  }
+  if (isPlainObject(value)) {
+    const options = {};
+    if (typeof value.key === "string") {
+      options.key = value.key;
+    }
+    if (typeof value.flatten === "boolean") {
+      options.flatten = value.flatten;
+    }
+    return options;
+  }
+  return {};
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveTargetElement(engine, target) {
+  if (!target) {
+    return engine.getCurrentElement();
+  }
+  if (target instanceof Element) {
+    return target;
+  }
+  if (Array.isArray(target) && target[0] instanceof Element) {
+    return target[0];
+  }
+  return engine.getCurrentElement();
+}
+function resolveItemscopeRoot(element) {
+  if (element.hasAttribute("itemscope")) {
+    return element;
+  }
+  return element.querySelector("[itemscope]") ?? void 0;
+}
+function extractMicrodata(root, options) {
+  const result = {};
+  const itemType = root.getAttribute("itemtype");
+  const itemId = root.getAttribute("itemid");
+  if (itemType) {
+    result[META_TYPE] = itemType;
+  }
+  if (itemId) {
+    result[META_ID] = itemId;
+  }
+  collectItemProps(root, result, options);
+  return result;
+}
+function collectItemProps(root, result, options) {
+  const children = Array.from(root.children);
+  for (const child of children) {
+    const hasItemprop = child.hasAttribute("itemprop");
+    const hasItemscope = child.hasAttribute("itemscope");
+    if (hasItemscope && !hasItemprop) {
+      continue;
+    }
+    if (hasItemprop) {
+      const props = (child.getAttribute("itemprop") ?? "").split(/\s+/).map((prop) => prop.trim()).filter(Boolean);
+      const value = hasItemscope ? extractMicrodata(child, options) : readItemValue(child);
+      for (const prop of props) {
+        addValue(result, prop, value);
+      }
+      if (options.flatten && value && typeof value === "object" && !Array.isArray(value)) {
+        for (const [key, nestedValue] of Object.entries(value)) {
+          if (key.startsWith("@")) {
+            continue;
+          }
+          addValue(result, key, nestedValue);
+        }
+      }
+      if (hasItemscope) {
+        continue;
+      }
+    }
+    collectItemProps(child, result, options);
+  }
+}
+function readItemValue(element) {
+  if (element instanceof HTMLMetaElement) {
+    return element.content ?? "";
+  }
+  if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+    return element.value ?? "";
+  }
+  if (element instanceof HTMLSelectElement) {
+    return element.value ?? "";
+  }
+  if (element instanceof HTMLTimeElement) {
+    return element.dateTime || element.getAttribute("datetime") || "";
+  }
+  if (element instanceof HTMLAnchorElement || element instanceof HTMLLinkElement) {
+    return element.getAttribute("href") ?? "";
+  }
+  if (element instanceof HTMLImageElement) {
+    return element.getAttribute("src") ?? "";
+  }
+  if (element.hasAttribute("content")) {
+    return element.getAttribute("content") ?? "";
+  }
+  return (element.textContent ?? "").trim();
+}
+function addValue(result, key, value) {
+  if (result[key] === void 0) {
+    result[key] = value;
+    return;
+  }
+  if (Array.isArray(result[key])) {
+    result[key].push(value);
+    return;
+  }
+  result[key] = [result[key], value];
+}
+function applyMicrodataToScope(scope, data, options) {
+  if (options.key) {
+    scope.setPath?.(options.key, data);
+    return;
+  }
+  for (const [key, value] of Object.entries(data)) {
+    if (key === META_TYPE) {
+      scope.setPath?.("itemtype", value);
+      continue;
+    }
+    if (key === META_ID) {
+      scope.setPath?.("itemid", value);
+      continue;
+    }
+    scope.setPath?.(key, value);
+  }
+}
+export {
+  microdata_default as default,
+  registerMicrodata
+};
+//# sourceMappingURL=microdata.js.map

package/dist/plugins/microdata.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/plugins/microdata.ts"],"sourcesContent":["import type { Engine } from \"../runtime/engine\";\n\ntype MicrodataOptions = {\n  key?: string;\n  flatten?: boolean;\n};\n\ntype ExtractResult = Record<string, any>;\n\nconst META_TYPE = \"@type\";\nconst META_ID = \"@id\";\n\nexport function registerMicrodata(engine: Engine): void {\n  engine.registerBehaviorModifier(\"microdata\", {\n    onBind: ({ element, scope, args }) => {\n      const options = normalizeOptions(args);\n      const root = resolveItemscopeRoot(element);\n      if (!root) {\n        return;\n      }\n      const data = extractMicrodata(root, options);\n      applyMicrodataToScope(scope, data, options);\n    }\n  });\n\n  engine.registerGlobal(\"microdata\", (target?: any, maybeOptions?: any) => {\n    const options = normalizeOptions(\n      isPlainObject(target) ? target : maybeOptions\n    );\n    const root = resolveTargetElement(engine, target);\n    if (!root) {\n      return undefined;\n    }\n    const data = extractMicrodata(resolveItemscopeRoot(root) ?? root, options);\n    if (typeof target === \"string\" && !isPlainObject(maybeOptions)) {\n      return data[target];\n    }\n    return data;\n  });\n}\n\nexport default registerMicrodata;\n\nconst globals = (globalThis as Record<string, any>);\nconst plugins = globals.VSNPlugins ?? {};\nplugins.microdata = (instance: Engine) => registerMicrodata(instance);\nglobals.VSNPlugins = plugins;\n\nconst autoEngine = globals.VSNEngine;\nif (autoEngine && typeof autoEngine.registerBehaviorModifier === \"function\") {\n  registerMicrodata(autoEngine as Engine);\n}\n\nfunction normalizeOptions(value: any): MicrodataOptions {\n  if (!value) {\n    return {};\n  }\n  if (typeof value === \"string\") {\n    return { key: value };\n  }\n  if (isPlainObject(value)) {\n    const options: MicrodataOptions = {};\n    if (typeof value.key === \"string\") {\n      options.key = value.key;\n    }\n    if (typeof value.flatten === \"boolean\") {\n      options.flatten = value.flatten;\n    }\n    return options;\n  }\n  return {};\n}\n\nfunction isPlainObject(value: any): value is Record<string, any> {\n  return Boolean(value) && typeof value === \"object\" && !Array.isArray(value);\n}\n\nfunction resolveTargetElement(engine: Engine, target?: any): Element | undefined {\n  if (!target) {\n    return engine.getCurrentElement();\n  }\n  if (target instanceof Element) {\n    return target;\n  }\n  if (Array.isArray(target) && target[0] instanceof Element) {\n    return target[0];\n  }\n  return engine.getCurrentElement();\n}\n\nfunction resolveItemscopeRoot(element: Element): Element | undefined {\n  if (element.hasAttribute(\"itemscope\")) {\n    return element;\n  }\n  return element.querySelector(\"[itemscope]\") ?? undefined;\n}\n\nfunction extractMicrodata(root: Element, options: MicrodataOptions): ExtractResult {\n  const result: ExtractResult = {};\n  const itemType = root.getAttribute(\"itemtype\");\n  const itemId = root.getAttribute(\"itemid\");\n  if (itemType) {\n    result[META_TYPE] = itemType;\n  }\n  if (itemId) {\n    result[META_ID] = itemId;\n  }\n\n  collectItemProps(root, result, options);\n  return result;\n}\n\nfunction collectItemProps(root: Element, result: ExtractResult, options: MicrodataOptions): void {\n  const children = Array.from(root.children);\n  for (const child of children) {\n    const hasItemprop = child.hasAttribute(\"itemprop\");\n    const hasItemscope = child.hasAttribute(\"itemscope\");\n\n    if (hasItemscope && !hasItemprop) {\n      continue;\n    }\n\n    if (hasItemprop) {\n      const props = (child.getAttribute(\"itemprop\") ?? \"\")\n        .split(/\\s+/)\n        .map((prop) => prop.trim())\n        .filter(Boolean);\n      const value = hasItemscope ? extractMicrodata(child, options) : readItemValue(child);\n      for (const prop of props) {\n        addValue(result, prop, value);\n      }\n      if (options.flatten && value && typeof value === \"object\" && !Array.isArray(value)) {\n        for (const [key, nestedValue] of Object.entries(value)) {\n          if (key.startsWith(\"@\")) {\n            continue;\n          }\n          addValue(result, key, nestedValue);\n        }\n      }\n      if (hasItemscope) {\n        continue;\n      }\n    }\n\n    collectItemProps(child, result, options);\n  }\n}\n\nfunction readItemValue(element: Element): string {\n  if (element instanceof HTMLMetaElement) {\n    return element.content ?? \"\";\n  }\n  if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {\n    return element.value ?? \"\";\n  }\n  if (element instanceof HTMLSelectElement) {\n    return element.value ?? \"\";\n  }\n  if (element instanceof HTMLTimeElement) {\n    return element.dateTime || element.getAttribute(\"datetime\") || \"\";\n  }\n  if (element instanceof HTMLAnchorElement || element instanceof HTMLLinkElement) {\n    return element.getAttribute(\"href\") ?? \"\";\n  }\n  if (element instanceof HTMLImageElement) {\n    return element.getAttribute(\"src\") ?? \"\";\n  }\n  if (element.hasAttribute(\"content\")) {\n    return element.getAttribute(\"content\") ?? \"\";\n  }\n  return (element.textContent ?? \"\").trim();\n}\n\nfunction addValue(result: ExtractResult, key: string, value: any): void {\n  if (result[key] === undefined) {\n    result[key] = value;\n    return;\n  }\n  if (Array.isArray(result[key])) {\n    result[key].push(value);\n    return;\n  }\n  result[key] = [result[key], value];\n}\n\nfunction applyMicrodataToScope(scope: any, data: ExtractResult, options: MicrodataOptions): void {\n  if (options.key) {\n    scope.setPath?.(options.key, data);\n    return;\n  }\n  for (const [key, value] of Object.entries(data)) {\n    if (key === META_TYPE) {\n      scope.setPath?.(\"itemtype\", value);\n      continue;\n    }\n    if (key === META_ID) {\n      scope.setPath?.(\"itemid\", value);\n      continue;\n    }\n    scope.setPath?.(key, value);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/plugins/microdata.min.js

@@ -0,0 +1,2 @@
+var A="@type";function p(t){t.registerBehaviorModifier("microdata",{onBind:({element:n,scope:i,args:r})=>{let e=E(r),o=l(n);if(!o)return;let s=d(o,e);I(i,s,e)}}),t.registerGlobal("microdata",(n,i)=>{let r=E(u(n)?n:i),e=T(t,n);if(!e)return;let o=d(l(e)??e,r);return typeof n=="string"&&!u(i)?o[n]:o})}var R=p,y=globalThis,g=y.VSNPlugins??{};g.microdata=t=>p(t);y.VSNPlugins=g;var f=y.VSNEngine;f&&typeof f.registerBehaviorModifier=="function"&&p(f);function E(t){if(!t)return{};if(typeof t=="string")return{key:t};if(u(t)){let n={};return typeof t.key=="string"&&(n.key=t.key),typeof t.flatten=="boolean"&&(n.flatten=t.flatten),n}return{}}function u(t){return!!t&&typeof t=="object"&&!Array.isArray(t)}function T(t,n){return n?n instanceof Element?n:Array.isArray(n)&&n[0]instanceof Element?n[0]:t.getCurrentElement():t.getCurrentElement()}function l(t){return t.hasAttribute("itemscope")?t:t.querySelector("[itemscope]")??void 0}function d(t,n){let i={},r=t.getAttribute("itemtype"),e=t.getAttribute("itemid");return r&&(i[A]=r),e&&(i["@id"]=e),M(t,i,n),i}function M(t,n,i){let r=Array.from(t.children);for(let e of r){let o=e.hasAttribute("itemprop"),s=e.hasAttribute("itemscope");if(!(s&&!o)){if(o){let b=(e.getAttribute("itemprop")??"").split(/\s+/).map(c=>c.trim()).filter(Boolean),a=s?d(e,i):x(e);for(let c of b)m(n,c,a);if(i.flatten&&a&&typeof a=="object"&&!Array.isArray(a))for(let[c,h]of Object.entries(a))c.startsWith("@")||m(n,c,h);if(s)continue}M(e,n,i)}}}function x(t){return t instanceof HTMLMetaElement?t.content??"":t instanceof HTMLInputElement||t instanceof HTMLTextAreaElement||t instanceof HTMLSelectElement?t.value??"":t instanceof HTMLTimeElement?t.dateTime||t.getAttribute("datetime")||"":t instanceof HTMLAnchorElement||t instanceof HTMLLinkElement?t.getAttribute("href")??"":t instanceof HTMLImageElement?t.getAttribute("src")??"":t.hasAttribute("content")?t.getAttribute("content")??"":(t.textContent??"").trim()}function m(t,n,i){if(t[n]===void 0){t[n]=i;return}if(Array.isArray(t[n])){t[n].push(i);return}t[n]=[t[n],i]}function I(t,n,i){if(i.key){t.setPath?.(i.key,n);return}for(let[r,e]of Object.entries(n)){if(r===A){t.setPath?.("itemtype",e);continue}if(r==="@id"){t.setPath?.("itemid",e);continue}t.setPath?.(r,e)}}export{R as default,p as registerMicrodata};
+//# sourceMappingURL=microdata.min.js.map