forked from FINAKON/HelpProject
Bhargava
6063bd1724
1. Initial Commit - a boiler plate code and POC to realize the concept of context
sensitive help
2. Frontend code written in ReactJS
3. Backend code written in Java, Spring Boot Framework
4. Frontend Start:
pre-requisites : node, npm
npm run dev ==> to start the frontend vite server
5. Backend Start:
pre-requisites : java, mvn
mvn spring-boot:run ==> to start the backend server
6. Visit http://localhost:5173/ for basic demo of help, press F1 in textboxes
7. Visit http://localhost:5173/editor and enter "admin123" to add/modify texts.
Happy Coding !!!
Thank you,
Bhargava.
587 lines
20 KiB
JavaScript
587 lines
20 KiB
JavaScript
/**
|
|
* @license React
|
|
* react-refresh-babel.production.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
"use strict";
|
|
module.exports = function (babel) {
|
|
function createRegistration(programPath, persistentID) {
|
|
var handle = programPath.scope.generateUidIdentifier("c");
|
|
registrationsByProgramPath.has(programPath) ||
|
|
registrationsByProgramPath.set(programPath, []);
|
|
registrationsByProgramPath
|
|
.get(programPath)
|
|
.push({ handle: handle, persistentID: persistentID });
|
|
return handle;
|
|
}
|
|
function isComponentishName(name) {
|
|
return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
|
|
}
|
|
function findInnerComponents(inferredName, path, callback) {
|
|
var node = path.node;
|
|
switch (node.type) {
|
|
case "Identifier":
|
|
if (!isComponentishName(node.name)) break;
|
|
callback(inferredName, node, null);
|
|
return !0;
|
|
case "FunctionDeclaration":
|
|
return callback(inferredName, node.id, null), !0;
|
|
case "ArrowFunctionExpression":
|
|
if ("ArrowFunctionExpression" === node.body.type) break;
|
|
callback(inferredName, node, path);
|
|
return !0;
|
|
case "FunctionExpression":
|
|
return callback(inferredName, node, path), !0;
|
|
case "CallExpression":
|
|
var argsPath = path.get("arguments");
|
|
if (void 0 === argsPath || 0 === argsPath.length) break;
|
|
var calleePath = path.get("callee");
|
|
switch (calleePath.node.type) {
|
|
case "MemberExpression":
|
|
case "Identifier":
|
|
calleePath = calleePath.getSource();
|
|
if (
|
|
!findInnerComponents(
|
|
inferredName + "$" + calleePath,
|
|
argsPath[0],
|
|
callback
|
|
)
|
|
)
|
|
return !1;
|
|
callback(inferredName, node, path);
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
case "VariableDeclarator":
|
|
if (
|
|
((argsPath = node.init),
|
|
null !== argsPath &&
|
|
((calleePath = node.id.name), isComponentishName(calleePath)))
|
|
) {
|
|
switch (argsPath.type) {
|
|
case "ArrowFunctionExpression":
|
|
case "FunctionExpression":
|
|
break;
|
|
case "CallExpression":
|
|
node = argsPath.callee;
|
|
var calleeType = node.type;
|
|
if (
|
|
"Import" === calleeType ||
|
|
("Identifier" === calleeType &&
|
|
(0 === node.name.indexOf("require") ||
|
|
0 === node.name.indexOf("import")))
|
|
)
|
|
return !1;
|
|
break;
|
|
case "TaggedTemplateExpression":
|
|
break;
|
|
default:
|
|
return !1;
|
|
}
|
|
node = path.get("init");
|
|
if (findInnerComponents(inferredName, node, callback)) return !0;
|
|
calleePath = path.scope.getBinding(calleePath);
|
|
if (void 0 === calleePath) return;
|
|
path = !1;
|
|
calleePath = calleePath.referencePaths;
|
|
for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
|
|
var ref = calleePath[calleeType];
|
|
if (
|
|
!ref.node ||
|
|
"JSXIdentifier" === ref.node.type ||
|
|
"Identifier" === ref.node.type
|
|
) {
|
|
ref = ref.parent;
|
|
if ("JSXOpeningElement" === ref.type) path = !0;
|
|
else if ("CallExpression" === ref.type) {
|
|
ref = ref.callee;
|
|
var fnName = void 0;
|
|
switch (ref.type) {
|
|
case "Identifier":
|
|
fnName = ref.name;
|
|
break;
|
|
case "MemberExpression":
|
|
fnName = ref.property.name;
|
|
}
|
|
switch (fnName) {
|
|
case "createElement":
|
|
case "jsx":
|
|
case "jsxDEV":
|
|
case "jsxs":
|
|
path = !0;
|
|
}
|
|
}
|
|
if (path) return callback(inferredName, argsPath, node), !0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !1;
|
|
}
|
|
function getHookCallsSignature(functionNode) {
|
|
functionNode = hookCalls.get(functionNode);
|
|
return void 0 === functionNode
|
|
? null
|
|
: {
|
|
key: functionNode
|
|
.map(function (call) {
|
|
return call.name + "{" + call.key + "}";
|
|
})
|
|
.join("\n"),
|
|
customHooks: functionNode
|
|
.filter(function (call) {
|
|
a: switch (call.name) {
|
|
case "useState":
|
|
case "React.useState":
|
|
case "useReducer":
|
|
case "React.useReducer":
|
|
case "useEffect":
|
|
case "React.useEffect":
|
|
case "useLayoutEffect":
|
|
case "React.useLayoutEffect":
|
|
case "useMemo":
|
|
case "React.useMemo":
|
|
case "useCallback":
|
|
case "React.useCallback":
|
|
case "useRef":
|
|
case "React.useRef":
|
|
case "useContext":
|
|
case "React.useContext":
|
|
case "useImperativeHandle":
|
|
case "React.useImperativeHandle":
|
|
case "useDebugValue":
|
|
case "React.useDebugValue":
|
|
case "useId":
|
|
case "React.useId":
|
|
case "useDeferredValue":
|
|
case "React.useDeferredValue":
|
|
case "useTransition":
|
|
case "React.useTransition":
|
|
case "useInsertionEffect":
|
|
case "React.useInsertionEffect":
|
|
case "useSyncExternalStore":
|
|
case "React.useSyncExternalStore":
|
|
case "useFormStatus":
|
|
case "React.useFormStatus":
|
|
case "useFormState":
|
|
case "React.useFormState":
|
|
case "useActionState":
|
|
case "React.useActionState":
|
|
case "useOptimistic":
|
|
case "React.useOptimistic":
|
|
call = !0;
|
|
break a;
|
|
default:
|
|
call = !1;
|
|
}
|
|
return !call;
|
|
})
|
|
.map(function (call) {
|
|
return t.cloneDeep(call.callee);
|
|
})
|
|
};
|
|
}
|
|
function hasForceResetComment(path) {
|
|
path = path.hub.file;
|
|
var hasForceReset = hasForceResetCommentByFile.get(path);
|
|
if (void 0 !== hasForceReset) return hasForceReset;
|
|
hasForceReset = !1;
|
|
for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
|
|
if (-1 !== comments[i].value.indexOf("@refresh reset")) {
|
|
hasForceReset = !0;
|
|
break;
|
|
}
|
|
hasForceResetCommentByFile.set(path, hasForceReset);
|
|
return hasForceReset;
|
|
}
|
|
function createArgumentsForSignature(node, signature, scope) {
|
|
var key = signature.key;
|
|
signature = signature.customHooks;
|
|
var forceReset = hasForceResetComment(scope.path),
|
|
customHooksInScope = [];
|
|
signature.forEach(function (callee) {
|
|
switch (callee.type) {
|
|
case "MemberExpression":
|
|
if ("Identifier" === callee.object.type)
|
|
var bindingName = callee.object.name;
|
|
break;
|
|
case "Identifier":
|
|
bindingName = callee.name;
|
|
}
|
|
scope.hasBinding(bindingName)
|
|
? customHooksInScope.push(callee)
|
|
: (forceReset = !0);
|
|
});
|
|
signature = key;
|
|
"function" !== typeof require ||
|
|
opts.emitFullSignatures ||
|
|
(signature = require("crypto")
|
|
.createHash("sha1")
|
|
.update(key)
|
|
.digest("base64"));
|
|
node = [node, t.stringLiteral(signature)];
|
|
(forceReset || 0 < customHooksInScope.length) &&
|
|
node.push(t.booleanLiteral(forceReset));
|
|
0 < customHooksInScope.length &&
|
|
node.push(
|
|
t.functionExpression(
|
|
null,
|
|
[],
|
|
t.blockStatement([
|
|
t.returnStatement(t.arrayExpression(customHooksInScope))
|
|
])
|
|
)
|
|
);
|
|
return node;
|
|
}
|
|
function findHOCCallPathsAbove(path) {
|
|
for (var calls = []; ; ) {
|
|
if (!path) return calls;
|
|
var parentPath = path.parentPath;
|
|
if (!parentPath) return calls;
|
|
if (
|
|
"AssignmentExpression" === parentPath.node.type &&
|
|
path.node === parentPath.node.right
|
|
)
|
|
path = parentPath;
|
|
else if (
|
|
"CallExpression" === parentPath.node.type &&
|
|
path.node !== parentPath.node.callee
|
|
)
|
|
calls.push(parentPath), (path = parentPath);
|
|
else return calls;
|
|
}
|
|
}
|
|
var opts =
|
|
1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
|
|
if ("function" === typeof babel.env) {
|
|
var env = babel.env();
|
|
if ("development" !== env && !opts.skipEnvCheck)
|
|
throw Error(
|
|
'React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "' +
|
|
env +
|
|
'". If you want to override this check, pass {skipEnvCheck: true} as plugin options.'
|
|
);
|
|
}
|
|
var t = babel.types,
|
|
refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
|
|
refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
|
|
registrationsByProgramPath = new Map(),
|
|
hasForceResetCommentByFile = new WeakMap(),
|
|
seenForRegistration = new WeakSet(),
|
|
seenForSignature = new WeakSet(),
|
|
seenForOutro = new WeakSet(),
|
|
hookCalls = new WeakMap(),
|
|
HookCallsVisitor = {
|
|
CallExpression: function (path) {
|
|
var callee = path.node.callee,
|
|
name = null;
|
|
switch (callee.type) {
|
|
case "Identifier":
|
|
name = callee.name;
|
|
break;
|
|
case "MemberExpression":
|
|
name = callee.property.name;
|
|
}
|
|
if (
|
|
null !== name &&
|
|
/^use[A-Z]/.test(name) &&
|
|
((callee = path.scope.getFunctionParent()), null !== callee)
|
|
) {
|
|
callee = callee.block;
|
|
hookCalls.has(callee) || hookCalls.set(callee, []);
|
|
callee = hookCalls.get(callee);
|
|
var key = "";
|
|
"VariableDeclarator" === path.parent.type &&
|
|
(key = path.parentPath.get("id").getSource());
|
|
var args = path.get("arguments");
|
|
"useState" === name && 0 < args.length
|
|
? (key += "(" + args[0].getSource() + ")")
|
|
: "useReducer" === name &&
|
|
1 < args.length &&
|
|
(key += "(" + args[1].getSource() + ")");
|
|
callee.push({ callee: path.node.callee, name: name, key: key });
|
|
}
|
|
}
|
|
};
|
|
return {
|
|
visitor: {
|
|
ExportDefaultDeclaration: function (path) {
|
|
var node = path.node,
|
|
decl = node.declaration,
|
|
declPath = path.get("declaration");
|
|
if ("CallExpression" === decl.type && !seenForRegistration.has(node)) {
|
|
seenForRegistration.add(node);
|
|
var programPath = path.parentPath;
|
|
findInnerComponents(
|
|
"%default%",
|
|
declPath,
|
|
function (persistentID, targetExpr, targetPath) {
|
|
null !== targetPath &&
|
|
((persistentID = createRegistration(programPath, persistentID)),
|
|
targetPath.replaceWith(
|
|
t.assignmentExpression("=", persistentID, targetExpr)
|
|
));
|
|
}
|
|
);
|
|
}
|
|
},
|
|
FunctionDeclaration: {
|
|
enter: function (path) {
|
|
var node = path.node,
|
|
modulePrefix = "";
|
|
switch (path.parent.type) {
|
|
case "Program":
|
|
var insertAfterPath = path;
|
|
var programPath = path.parentPath;
|
|
break;
|
|
case "TSModuleBlock":
|
|
insertAfterPath = path;
|
|
programPath = insertAfterPath.parentPath.parentPath;
|
|
break;
|
|
case "ExportNamedDeclaration":
|
|
insertAfterPath = path.parentPath;
|
|
programPath = insertAfterPath.parentPath;
|
|
break;
|
|
case "ExportDefaultDeclaration":
|
|
insertAfterPath = path.parentPath;
|
|
programPath = insertAfterPath.parentPath;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if (
|
|
"TSModuleBlock" === path.parent.type ||
|
|
"ExportNamedDeclaration" === path.parent.type
|
|
)
|
|
for (; "Program" !== programPath.type; ) {
|
|
if ("TSModuleDeclaration" === programPath.type) {
|
|
if (
|
|
"Program" !== programPath.parentPath.type &&
|
|
"ExportNamedDeclaration" !== programPath.parentPath.type
|
|
)
|
|
return;
|
|
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
|
|
}
|
|
programPath = programPath.parentPath;
|
|
}
|
|
var id = node.id;
|
|
null !== id &&
|
|
((id = id.name),
|
|
isComponentishName(id) &&
|
|
!seenForRegistration.has(node) &&
|
|
(seenForRegistration.add(node),
|
|
findInnerComponents(
|
|
modulePrefix + id,
|
|
path,
|
|
function (persistentID, targetExpr) {
|
|
persistentID = createRegistration(programPath, persistentID);
|
|
insertAfterPath.insertAfter(
|
|
t.expressionStatement(
|
|
t.assignmentExpression("=", persistentID, targetExpr)
|
|
)
|
|
);
|
|
}
|
|
)));
|
|
},
|
|
exit: function (path) {
|
|
var node = path.node,
|
|
id = node.id;
|
|
if (null !== id) {
|
|
var signature = getHookCallsSignature(node);
|
|
if (null !== signature && !seenForSignature.has(node)) {
|
|
seenForSignature.add(node);
|
|
node = path.scope.generateUidIdentifier("_s");
|
|
path.scope.parent.push({
|
|
id: node,
|
|
init: t.callExpression(refreshSig, [])
|
|
});
|
|
path
|
|
.get("body")
|
|
.unshiftContainer(
|
|
"body",
|
|
t.expressionStatement(t.callExpression(node, []))
|
|
);
|
|
var insertAfterPath = null;
|
|
path.find(function (p) {
|
|
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
|
|
});
|
|
null !== insertAfterPath &&
|
|
insertAfterPath.insertAfter(
|
|
t.expressionStatement(
|
|
t.callExpression(
|
|
node,
|
|
createArgumentsForSignature(
|
|
id,
|
|
signature,
|
|
insertAfterPath.scope
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"ArrowFunctionExpression|FunctionExpression": {
|
|
exit: function (path) {
|
|
var node = path.node,
|
|
signature = getHookCallsSignature(node);
|
|
if (null !== signature && !seenForSignature.has(node)) {
|
|
seenForSignature.add(node);
|
|
var sigCallID = path.scope.generateUidIdentifier("_s");
|
|
path.scope.parent.push({
|
|
id: sigCallID,
|
|
init: t.callExpression(refreshSig, [])
|
|
});
|
|
"BlockStatement" !== path.node.body.type &&
|
|
(path.node.body = t.blockStatement([
|
|
t.returnStatement(path.node.body)
|
|
]));
|
|
path
|
|
.get("body")
|
|
.unshiftContainer(
|
|
"body",
|
|
t.expressionStatement(t.callExpression(sigCallID, []))
|
|
);
|
|
if ("VariableDeclarator" === path.parent.type) {
|
|
var insertAfterPath = null;
|
|
path.find(function (p) {
|
|
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
|
|
});
|
|
null !== insertAfterPath &&
|
|
insertAfterPath.insertAfter(
|
|
t.expressionStatement(
|
|
t.callExpression(
|
|
sigCallID,
|
|
createArgumentsForSignature(
|
|
path.parent.id,
|
|
signature,
|
|
insertAfterPath.scope
|
|
)
|
|
)
|
|
)
|
|
);
|
|
} else
|
|
[path].concat(findHOCCallPathsAbove(path)).forEach(function (p) {
|
|
p.replaceWith(
|
|
t.callExpression(
|
|
sigCallID,
|
|
createArgumentsForSignature(p.node, signature, p.scope)
|
|
)
|
|
);
|
|
});
|
|
}
|
|
}
|
|
},
|
|
VariableDeclaration: function (path) {
|
|
var node = path.node,
|
|
modulePrefix = "";
|
|
switch (path.parent.type) {
|
|
case "Program":
|
|
var insertAfterPath = path;
|
|
var programPath = path.parentPath;
|
|
break;
|
|
case "TSModuleBlock":
|
|
insertAfterPath = path;
|
|
programPath = insertAfterPath.parentPath.parentPath;
|
|
break;
|
|
case "ExportNamedDeclaration":
|
|
insertAfterPath = path.parentPath;
|
|
programPath = insertAfterPath.parentPath;
|
|
break;
|
|
case "ExportDefaultDeclaration":
|
|
insertAfterPath = path.parentPath;
|
|
programPath = insertAfterPath.parentPath;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
if (
|
|
"TSModuleBlock" === path.parent.type ||
|
|
"ExportNamedDeclaration" === path.parent.type
|
|
)
|
|
for (; "Program" !== programPath.type; ) {
|
|
if ("TSModuleDeclaration" === programPath.type) {
|
|
if (
|
|
"Program" !== programPath.parentPath.type &&
|
|
"ExportNamedDeclaration" !== programPath.parentPath.type
|
|
)
|
|
return;
|
|
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
|
|
}
|
|
programPath = programPath.parentPath;
|
|
}
|
|
if (
|
|
!seenForRegistration.has(node) &&
|
|
(seenForRegistration.add(node),
|
|
(path = path.get("declarations")),
|
|
1 === path.length)
|
|
) {
|
|
var declPath = path[0];
|
|
findInnerComponents(
|
|
modulePrefix + declPath.node.id.name,
|
|
declPath,
|
|
function (persistentID, targetExpr, targetPath) {
|
|
null !== targetPath &&
|
|
((persistentID = createRegistration(programPath, persistentID)),
|
|
"VariableDeclarator" === targetPath.parent.type
|
|
? insertAfterPath.insertAfter(
|
|
t.expressionStatement(
|
|
t.assignmentExpression(
|
|
"=",
|
|
persistentID,
|
|
declPath.node.id
|
|
)
|
|
)
|
|
)
|
|
: targetPath.replaceWith(
|
|
t.assignmentExpression("=", persistentID, targetExpr)
|
|
));
|
|
}
|
|
);
|
|
}
|
|
},
|
|
Program: {
|
|
enter: function (path) {
|
|
path.traverse(HookCallsVisitor);
|
|
},
|
|
exit: function (path) {
|
|
var registrations = registrationsByProgramPath.get(path);
|
|
if (void 0 !== registrations) {
|
|
var node = path.node;
|
|
if (!seenForOutro.has(node)) {
|
|
seenForOutro.add(node);
|
|
registrationsByProgramPath.delete(path);
|
|
var declarators = [];
|
|
path.pushContainer(
|
|
"body",
|
|
t.variableDeclaration("var", declarators)
|
|
);
|
|
registrations.forEach(function (_ref) {
|
|
var handle = _ref.handle;
|
|
path.pushContainer(
|
|
"body",
|
|
t.expressionStatement(
|
|
t.callExpression(refreshReg, [
|
|
handle,
|
|
t.stringLiteral(_ref.persistentID)
|
|
])
|
|
)
|
|
);
|
|
declarators.push(t.variableDeclarator(handle));
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|