@syrin/iris 0.4.0

package/dist/eslint.d.ts

@@ -0,0 +1,22 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+import * as __options_js from './options.js';
+export { requireSignalOnMutation } from './require-signal-on-mutation.js';
+
+declare const rules: {
+    readonly "require-signal-on-mutation": _typescript_eslint_utils_ts_eslint.RuleModule<"mutationWithoutSignal", [__options_js.RawRuleOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+};
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        readonly "require-signal-on-mutation": _typescript_eslint_utils_ts_eslint.RuleModule<"mutationWithoutSignal", [__options_js.RawRuleOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+    };
+    configs: Record<string, unknown>;
+};
+
+export { plugin as default, rules };

package/dist/eslint.js

@@ -0,0 +1,134 @@
+// ../eslint-plugin/dist/require-signal-on-mutation.js
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+// ../eslint-plugin/dist/constants.js
+var RULE_NAME = "require-signal-on-mutation";
+var MessageId = {
+  MUTATION_WITHOUT_SIGNAL: "mutationWithoutSignal"
+};
+var MUTATION_WITHOUT_SIGNAL_MESSAGE = "store mutation without a mapped Iris signal";
+var DEFAULT_SIGNAL_CALLEES = ["irisSignal", "signal"];
+var DEFAULT_MUTATORS = [];
+var PLUGIN_NAME = "iris";
+var DOCS_URL_ROOT = "https://github.com/syrin-labs/iris/blob/main/packages/eslint-plugin/README.md";
+
+// ../eslint-plugin/dist/options.js
+var OPTIONS_SCHEMA = [
+  {
+    type: "object",
+    properties: {
+      mutators: {
+        type: "array",
+        items: { type: "string" }
+      },
+      signalCallee: {
+        oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+      }
+    },
+    additionalProperties: false
+  }
+];
+function toNonEmptySet(values) {
+  return new Set(values.filter((v) => v.length > 0));
+}
+function normalizeOptions(raw) {
+  const mutatorList = raw?.mutators ?? DEFAULT_MUTATORS;
+  const rawSignal = raw?.signalCallee;
+  let signalList;
+  if (rawSignal === void 0) {
+    signalList = DEFAULT_SIGNAL_CALLEES;
+  } else if (typeof rawSignal === "string") {
+    signalList = [rawSignal];
+  } else {
+    signalList = rawSignal;
+  }
+  return {
+    mutators: toNonEmptySet(mutatorList),
+    signalCallees: toNonEmptySet(signalList)
+  };
+}
+
+// ../eslint-plugin/dist/require-signal-on-mutation.js
+var createRule = ESLintUtils.RuleCreator((name) => `${DOCS_URL_ROOT}#${name}`);
+function calleeName(node) {
+  const callee = node.callee;
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === AST_NODE_TYPES.MemberExpression && callee.computed === false && callee.property.type === AST_NODE_TYPES.Identifier) {
+    return callee.property.name;
+  }
+  return null;
+}
+var requireSignalOnMutation = createRule({
+  name: "require-signal-on-mutation",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require an Iris signal alongside any user-visible store mutation so the signal layer cannot drift."
+    },
+    schema: OPTIONS_SCHEMA,
+    messages: {
+      [MessageId.MUTATION_WITHOUT_SIGNAL]: MUTATION_WITHOUT_SIGNAL_MESSAGE
+    }
+  },
+  defaultOptions: [{}],
+  create(context) {
+    const { mutators, signalCallees } = normalizeOptions(context.options[0]);
+    const stack = [];
+    function enterFn() {
+      stack.push({ calledSignal: false, mutatorNode: null });
+    }
+    function exitFn() {
+      const frame = stack.pop();
+      if (frame === void 0)
+        return;
+      if (frame.mutatorNode !== null && frame.calledSignal === false) {
+        context.report({
+          node: frame.mutatorNode,
+          messageId: MessageId.MUTATION_WITHOUT_SIGNAL
+        });
+      }
+    }
+    return {
+      FunctionDeclaration: enterFn,
+      "FunctionDeclaration:exit": exitFn,
+      FunctionExpression: enterFn,
+      "FunctionExpression:exit": exitFn,
+      ArrowFunctionExpression: enterFn,
+      "ArrowFunctionExpression:exit": exitFn,
+      CallExpression(node) {
+        const frame = stack.at(-1);
+        if (frame === void 0)
+          return;
+        const name = calleeName(node);
+        if (name === null)
+          return;
+        if (mutators.has(name) && frame.mutatorNode === null) {
+          frame.mutatorNode = node;
+        }
+        if (signalCallees.has(name)) {
+          frame.calledSignal = true;
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/dist/index.js
+var rules = { [RULE_NAME]: requireSignalOnMutation };
+var plugin = {
+  meta: { name: PLUGIN_NAME },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { [PLUGIN_NAME]: plugin },
+  rules: { [`${PLUGIN_NAME}/${RULE_NAME}`]: "warn" }
+};
+var dist_default = plugin;
+export {
+  dist_default as default,
+  requireSignalOnMutation,
+  rules
+};

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { Iris } from './iris.js';
+export { Iris, IrisConnectOptions } from './iris.js';
+import { ComponentStateResult } from './constants.js';
+export { SESSION_AUTO } from './constants.js';
+import { ComponentInfo } from './registry/adapters.js';
+export { ComponentInfo, ComponentSource, IrisAdapter, adapterNames, elementHasHoverHandlers, identifyComponent, readComponentState, registerAdapter } from './registry/adapters.js';
+export { Capabilities, CapabilitiesInput, CapabilityFlow, getCapabilities, hasCapabilities, registerCapabilities } from './registry/capabilities.js';
+export { CreateIrisEmitterOptions, EmitterTarget, IrisEmitter, createIrisEmitter } from './registry/emitter.js';
+export { IrisDomain, registerIrisDomain } from './registry/domains.js';
+export { RefRegistry, refs } from './dom/refs.js';
+export { StoreGetter, readStores, registerStore, storeNames, unregisterStore } from './registry/stores.js';
+export { buildSnapshot } from './dom/snapshot.js';
+export { commitAndSignal } from './registry/commit-and-signal.js';
+export { describe, getAccessibleName, getRole, getStates, isVisible } from './dom/a11y.js';
+export { executeAction, executeSequence } from './actions/actions.js';
+export { matchQuery, runQuery } from './dom/query.js';
+export { setIgnoreSelectors } from './dom/dom-ignore.js';
+
+declare const iris: Iris;
+
+/** Walk the fiber tree from a DOM node up to the root, collecting components + source. */
+declare function identify(el: Element): ComponentInfo | null;
+declare function readState(el: Element): ComponentStateResult;
+/**
+ * True if the element's host fiber declares React enter/leave handlers. Synthetic dispatchEvent
+ * does not reliably trigger React's native enter/leave synthesis (no hit-testing), so callers warn.
+ * Fail soft: any unexpected fiber shape returns false.
+ */
+declare function hasHoverHandlers(el: Element): boolean;
+/** Register the React adapter so `iris.inspect` returns component stack + source file. */
+declare function install(): void;
+
+export { hasHoverHandlers, identify, install, iris, readState };