🚀 Socket Launch Week Day 5:Introducing Repository Access Permissions and Custom Roles.Learn more →
Sign In

@solid-devtools/debugger

Package Overview
Dependencies
Maintainers
1
Versions
66
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@solid-devtools/debugger - npm Package Compare versions

Comparing version
0.2.1
 to
0.2.2
+22
-190
dist/server.cjs

@@ -24,3 +24,3 @@ "use strict";

Debugger: () => Debugger,
attachDebugger: () => attachDebugger2,
attachDebugger: () => attachDebugger,
createInternalRoot: () => createInternalRoot2,

@@ -33,3 +33,3 @@ createUnownedRoot: () => createUnownedRoot,

getSafeValue: () => getSafeValue,
interceptComputationRerun: () => interceptComputationRerun2,
interceptComputationRerun: () => interceptComputationRerun,
isSolidComputation: () => isSolidComputation2,

@@ -39,12 +39,12 @@ isSolidMemo: () => isSolidMemo2,

isSolidRoot: () => isSolidRoot2,
makeCreateRootListener: () => makeCreateRootListener2,
makeSolidUpdateListener: () => makeSolidUpdateListener2,
observeComputationUpdate: () => observeComputationUpdate2,
observeValueUpdate: () => observeValueUpdate2,
makeCreateRootListener: () => makeCreateRootListener,
makeSolidUpdateListener: () => makeSolidUpdateListener,
observeComputationUpdate: () => observeComputationUpdate,
observeValueUpdate: () => observeValueUpdate,
onOwnerCleanup: () => onOwnerCleanup2,
onParentCleanup: () => onParentCleanup2,
registerDebuggerPlugin: () => registerDebuggerPlugin2
registerDebuggerPlugin: () => registerDebuggerPlugin
});
module.exports = __toCommonJS(server_exports);
var import_utils10 = require("@solid-primitives/utils");
var import_utils4 = require("@solid-primitives/utils");

@@ -56,36 +56,10 @@ // ../shared/variables.ts

// src/server.ts
var import_solid_js7 = require("solid-js");
var import_solid_js3 = require("solid-js");
// src/primitives.ts
var import_solid_js6 = require("solid-js");
var import_scheduled = require("@solid-primitives/scheduled");
// ../shared/graph.ts
var import_solid_js = require("solid-js");
var getOwner = import_solid_js.getOwner;
// ../shared/messanger.ts
// src/utils.ts
var import_solid_js2 = require("solid-js");
var import_utils = require("@solid-primitives/utils");
// src/batchUpdates.ts
var import_solid_js2 = require("solid-js");
var import_utils2 = require("@solid-primitives/utils");
var updateBatchQueue = [];
var batchUpdateListeners = /* @__PURE__ */ new Set();
var callBatchUpdateListeners = (0, import_utils2.chain)(batchUpdateListeners);
var emitBatchUpdates = (0, import_utils2.createMicrotask)(() => {
callBatchUpdateListeners([...updateBatchQueue]);
updateBatchQueue = [];
});
function makeBatchUpdateListener(listener) {
batchUpdateListeners.add(listener);
return (0, import_solid_js2.onCleanup)(() => batchUpdateListeners.delete(listener));
}
// src/walker.ts
var import_refs = require("@solid-primitives/refs");
// src/utils.ts
var import_solid_js3 = require("solid-js");
var import_utils3 = require("@solid-primitives/utils");
var literalTypes = ["bigint", "number", "boolean", "string", "undefined"];

@@ -97,158 +71,16 @@ function getSafeValue(value) {

}
function setDebuggerContext(owner, ctx) {
owner.sdtContext = ctx;
}
var DISPOSE_ID = Symbol("Dispose ID");
function createUnownedRoot(fn) {
return (0, import_solid_js3.runWithOwner)(null, () => (0, import_solid_js3.createRoot)(fn));
return (0, import_solid_js2.runWithOwner)(null, () => (0, import_solid_js2.createRoot)(fn));
}
function createConsumers() {
const [consumers, setConsumers] = (0, import_solid_js3.createSignal)([], { name: "consumers" });
const enabled2 = (0, import_solid_js3.createMemo)(() => consumers().some((consumer) => consumer()));
return [enabled2, (consumer) => setConsumers((p) => [...p, consumer])];
}
var SkipInternalRoot = null;
function createInternalRoot(fn, detachedOwner) {
SkipInternalRoot = fn;
const v = (0, import_solid_js3.createRoot)((dispose) => {
const owner = getOwner();
setDebuggerContext(owner, INTERNAL);
return fn(dispose);
}, detachedOwner);
if (SkipInternalRoot === fn)
SkipInternalRoot = null;
return v;
}
var skipInternalRoot = () => {
const skip = !!SkipInternalRoot;
if (skip)
SkipInternalRoot = null;
return skip;
};
// src/update.ts
var import_solid_js4 = require("solid-js");
var GraphUpdateListeners = /* @__PURE__ */ new Set();
{
const runListeners = () => GraphUpdateListeners.forEach((f) => f());
if (typeof window._$afterUpdate === "function") {
GraphUpdateListeners.add(window._$afterUpdate);
}
window._$afterUpdate = runListeners;
}
var CreateRootListeners = /* @__PURE__ */ new Set();
{
const runListeners = (root) => {
if (skipInternalRoot())
return;
CreateRootListeners.forEach((f) => f(root));
};
if (typeof window._$afterCreateRoot === "function") {
CreateRootListeners.add(window._$afterCreateRoot);
}
window._$afterCreateRoot = runListeners;
}
// src/walker.ts
var WALKER = Symbol("walker");
// src/plugin.ts
var import_solid_js5 = require("solid-js");
var import_event_bus = require("@solid-primitives/event-bus");
var import_immutable = require("@solid-primitives/immutable");
var import_memo = require("@solid-primitives/memo");
var api = createInternalRoot(() => {
const owner = (0, import_solid_js5.getOwner)();
const [onUpdate2, triggerUpdate2] = (0, import_event_bus.createSimpleEmitter)();
const [onForceUpdate2, forceTriggerUpdate2] = (0, import_event_bus.createSimpleEmitter)();
const [enabled2, addDebuggerConsumer] = createConsumers();
const [trackSignals, addTrackSignalsConsumer] = createConsumers();
const [trackBatchedUpdates, addTrackBatchedUpdatesConsumer] = createConsumers();
const [trackComponents, addTrackComponentsConsumer] = createConsumers();
const [roots2, setRoots2] = (0, import_solid_js5.createSignal)([]);
const components = (0, import_memo.createLazyMemo)(() => roots2().reduce((arr, root) => {
arr.push.apply(arr, root.components);
return arr;
}, []));
const serialisedRoots = (0, import_memo.createLazyMemo)(() => roots2().map((root) => ({
id: root.id,
tree: root.tree
})));
const debuggerConfig2 = {
get enabled() {
return enabled2();
},
get trackSignals() {
return trackSignals();
},
get trackBatchedUpdates() {
return trackBatchedUpdates();
},
get trackComponents() {
return trackComponents();
}
};
function registerDebuggerPlugin3(factory) {
(0, import_solid_js5.runWithOwner)(owner, () => {
const { enabled: enabled3, trackBatchedUpdates: trackBatchedUpdates2, trackComponents: trackComponents2, trackSignals: trackSignals2 } = factory({
makeBatchUpdateListener,
roots: roots2,
components,
triggerUpdate: triggerUpdate2,
forceTriggerUpdate: forceTriggerUpdate2,
serialisedRoots
});
enabled3 && addDebuggerConsumer(enabled3);
trackBatchedUpdates2 && addTrackBatchedUpdatesConsumer(trackBatchedUpdates2);
trackComponents2 && addTrackComponentsConsumer(trackComponents2);
trackSignals2 && addTrackSignalsConsumer(trackSignals2);
});
}
return {
onUpdate: onUpdate2,
onForceUpdate: onForceUpdate2,
triggerUpdate: triggerUpdate2,
forceTriggerUpdate: forceTriggerUpdate2,
enabled: enabled2,
debuggerConfig: debuggerConfig2,
roots: roots2,
setRoots: setRoots2,
registerDebuggerPlugin: registerDebuggerPlugin3,
updateRoot(root) {
setRoots2((arr) => {
const index = arr.findIndex((o) => o.id === root.id);
return index !== -1 ? (0, import_immutable.splice)(arr, index, 1, root) : (0, import_immutable.push)(arr, root);
});
},
removeRoot(rootId) {
setRoots2((arr) => {
const index = arr.findIndex((o) => o.id === rootId);
return (0, import_immutable.splice)(arr, index, 1);
});
}
};
});
var {
onUpdate,
onForceUpdate,
triggerUpdate,
forceTriggerUpdate,
enabled,
debuggerConfig,
roots,
setRoots,
registerDebuggerPlugin,
updateRoot,
removeRoot
} = api;
// src/server.ts
var Debugger = (props) => props.children;
var attachDebugger2 = import_utils10.noop;
var registerDebuggerPlugin2 = import_utils10.noop;
var makeSolidUpdateListener2 = () => import_utils10.noop;
var makeCreateRootListener2 = () => import_utils10.noop;
var observeComputationUpdate2 = import_utils10.noop;
var observeValueUpdate2 = () => import_utils10.noop;
var interceptComputationRerun2 = import_utils10.noop;
var attachDebugger = import_utils4.noop;
var registerDebuggerPlugin = import_utils4.noop;
var makeSolidUpdateListener = () => import_utils4.noop;
var makeCreateRootListener = () => import_utils4.noop;
var observeComputationUpdate = import_utils4.noop;
var observeValueUpdate = () => import_utils4.noop;
var interceptComputationRerun = import_utils4.noop;
var getOwnerType2 = () => 0;

@@ -261,6 +93,6 @@ var getNodeType2 = () => 0;

var isSolidRoot2 = (o) => false;
var onOwnerCleanup2 = () => import_utils10.noop;
var onParentCleanup2 = () => import_utils10.noop;
var onOwnerCleanup2 = () => import_utils4.noop;
var onParentCleanup2 = () => import_utils4.noop;
var getFunctionSources2 = () => [];
var createInternalRoot2 = import_solid_js7.createRoot;
var createInternalRoot2 = import_solid_js3.createRoot;
// Annotate the CommonJS export names for ESM import in node:

@@ -267,0 +99,0 @@ 0 && (module.exports = {

+3
-3
package.json
{
"name": "@solid-devtools/debugger",
"version": "0.2.1",
"version": "0.2.2",
"description": "Debugger of the Solid's reactivity graph — a cornerstone of all solid-devtools.",

@@ -8,3 +8,3 @@ "license": "MIT",

"contributors": [],
"homepage": "https://github.com/thetarnav/solid-devtools#readme",
"homepage": "https://github.com/thetarnav/solid-devtools/tree/main/packages/debugger#readme",
"repository": {

@@ -24,3 +24,3 @@ "type": "git",

"private": false,
"sideEffects": true,
"sideEffects": false,
"publishConfig": {

@@ -27,0 +27,0 @@ "access": "public"