This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
230 lines
5.7 KiB
230 lines
5.7 KiB
"use strict"; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.default = exports.environmentVisitor = void 0; |
|
|
|
function _traverse() { |
|
const data = _interopRequireDefault(require("@babel/traverse")); |
|
|
|
_traverse = function () { |
|
return data; |
|
}; |
|
|
|
return data; |
|
} |
|
|
|
function _helperMemberExpressionToFunctions() { |
|
const data = _interopRequireDefault(require("@babel/helper-member-expression-to-functions")); |
|
|
|
_helperMemberExpressionToFunctions = function () { |
|
return data; |
|
}; |
|
|
|
return data; |
|
} |
|
|
|
function _helperOptimiseCallExpression() { |
|
const data = _interopRequireDefault(require("@babel/helper-optimise-call-expression")); |
|
|
|
_helperOptimiseCallExpression = function () { |
|
return data; |
|
}; |
|
|
|
return data; |
|
} |
|
|
|
function t() { |
|
const data = _interopRequireWildcard(require("@babel/types")); |
|
|
|
t = function () { |
|
return data; |
|
}; |
|
|
|
return data; |
|
} |
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function getPrototypeOfExpression(objectRef, isStatic, file) { |
|
objectRef = t().cloneNode(objectRef); |
|
const targetRef = isStatic ? objectRef : t().memberExpression(objectRef, t().identifier("prototype")); |
|
return t().callExpression(file.addHelper("getPrototypeOf"), [targetRef]); |
|
} |
|
|
|
function skipAllButComputedKey(path) { |
|
if (!path.node.computed) { |
|
path.skip(); |
|
return; |
|
} |
|
|
|
const keys = t().VISITOR_KEYS[path.type]; |
|
|
|
for (const key of keys) { |
|
if (key !== "key") path.skipKey(key); |
|
} |
|
} |
|
|
|
const environmentVisitor = { |
|
Function(path) { |
|
if (path.isMethod()) return; |
|
if (path.isArrowFunctionExpression()) return; |
|
path.skip(); |
|
}, |
|
|
|
Method(path) { |
|
skipAllButComputedKey(path); |
|
}, |
|
|
|
"ClassProperty|ClassPrivateProperty"(path) { |
|
if (path.node.static) return; |
|
skipAllButComputedKey(path); |
|
} |
|
|
|
}; |
|
exports.environmentVisitor = environmentVisitor; |
|
|
|
const visitor = _traverse().default.visitors.merge([environmentVisitor, { |
|
Super(path, state) { |
|
const { |
|
node, |
|
parentPath |
|
} = path; |
|
if (!parentPath.isMemberExpression({ |
|
object: node |
|
})) return; |
|
state.handle(parentPath); |
|
} |
|
|
|
}]); |
|
|
|
const specHandlers = { |
|
memoise(superMember, count) { |
|
const { |
|
scope, |
|
node |
|
} = superMember; |
|
const { |
|
computed, |
|
property |
|
} = node; |
|
|
|
if (!computed) { |
|
return; |
|
} |
|
|
|
const memo = scope.maybeGenerateMemoised(property); |
|
|
|
if (!memo) { |
|
return; |
|
} |
|
|
|
this.memoiser.set(property, memo, count); |
|
}, |
|
|
|
prop(superMember) { |
|
const { |
|
computed, |
|
property |
|
} = superMember.node; |
|
|
|
if (this.memoiser.has(property)) { |
|
return t().cloneNode(this.memoiser.get(property)); |
|
} |
|
|
|
if (computed) { |
|
return t().cloneNode(property); |
|
} |
|
|
|
return t().stringLiteral(property.name); |
|
}, |
|
|
|
get(superMember) { |
|
return t().callExpression(this.file.addHelper("get"), [getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file), this.prop(superMember), t().thisExpression()]); |
|
}, |
|
|
|
set(superMember, value) { |
|
return t().callExpression(this.file.addHelper("set"), [getPrototypeOfExpression(this.getObjectRef(), this.isStatic, this.file), this.prop(superMember), value, t().thisExpression(), t().booleanLiteral(superMember.isInStrictMode())]); |
|
}, |
|
|
|
call(superMember, args) { |
|
return (0, _helperOptimiseCallExpression().default)(this.get(superMember), t().thisExpression(), args); |
|
} |
|
|
|
}; |
|
const looseHandlers = Object.assign({}, specHandlers, { |
|
prop(superMember) { |
|
const { |
|
property |
|
} = superMember.node; |
|
|
|
if (this.memoiser.has(property)) { |
|
return t().cloneNode(this.memoiser.get(property)); |
|
} |
|
|
|
return t().cloneNode(property); |
|
}, |
|
|
|
get(superMember) { |
|
const { |
|
isStatic, |
|
superRef |
|
} = this; |
|
const { |
|
computed |
|
} = superMember.node; |
|
const prop = this.prop(superMember); |
|
let object; |
|
|
|
if (isStatic) { |
|
object = superRef ? t().cloneNode(superRef) : t().memberExpression(t().identifier("Function"), t().identifier("prototype")); |
|
} else { |
|
object = superRef ? t().memberExpression(t().cloneNode(superRef), t().identifier("prototype")) : t().memberExpression(t().identifier("Object"), t().identifier("prototype")); |
|
} |
|
|
|
return t().memberExpression(object, prop, computed); |
|
}, |
|
|
|
set(superMember, value) { |
|
const { |
|
computed |
|
} = superMember.node; |
|
const prop = this.prop(superMember); |
|
return t().assignmentExpression("=", t().memberExpression(t().thisExpression(), prop, computed), value); |
|
} |
|
|
|
}); |
|
|
|
class ReplaceSupers { |
|
constructor(opts) { |
|
const path = opts.methodPath; |
|
this.methodPath = path; |
|
this.isStatic = path.isClassMethod({ |
|
static: true |
|
}) || path.isObjectMethod(); |
|
this.file = opts.file; |
|
this.superRef = opts.superRef; |
|
this.isLoose = opts.isLoose; |
|
this.opts = opts; |
|
} |
|
|
|
getObjectRef() { |
|
return t().cloneNode(this.opts.objectRef || this.opts.getObjectRef()); |
|
} |
|
|
|
replace() { |
|
const handler = this.isLoose ? looseHandlers : specHandlers; |
|
(0, _helperMemberExpressionToFunctions().default)(this.methodPath, visitor, Object.assign({ |
|
file: this.file, |
|
isStatic: this.isStatic, |
|
getObjectRef: this.getObjectRef.bind(this), |
|
superRef: this.superRef |
|
}, handler)); |
|
} |
|
|
|
} |
|
|
|
exports.default = ReplaceSupers; |