330 lines
11 KiB
JavaScript
330 lines
11 KiB
JavaScript
/* global Ember */
|
|
import { dasherize, decamelize } from "@ember/string";
|
|
import deprecated from "discourse-common/lib/deprecated";
|
|
import { findHelper } from "discourse-common/lib/helpers";
|
|
import SuffixTrie from "discourse-common/lib/suffix-trie";
|
|
import Resolver from "ember-resolver";
|
|
import { buildResolver as buildLegacyResolver } from "discourse-common/lib/legacy-resolver";
|
|
|
|
let _options = {};
|
|
let moduleSuffixTrie = null;
|
|
|
|
export function setResolverOption(name, value) {
|
|
_options[name] = value;
|
|
}
|
|
|
|
export function getResolverOption(name) {
|
|
return _options[name];
|
|
}
|
|
|
|
export function clearResolverOptions() {
|
|
_options = {};
|
|
}
|
|
|
|
function lookupModuleBySuffix(suffix) {
|
|
if (!moduleSuffixTrie) {
|
|
moduleSuffixTrie = new SuffixTrie("/");
|
|
Object.keys(requirejs.entries).forEach((name) => {
|
|
if (!name.includes("/templates/")) {
|
|
moduleSuffixTrie.add(name);
|
|
}
|
|
});
|
|
}
|
|
return moduleSuffixTrie.withSuffix(suffix, 1)[0];
|
|
}
|
|
|
|
export function buildResolver(baseName) {
|
|
let LegacyResolver = buildLegacyResolver(baseName);
|
|
|
|
return class extends Resolver {
|
|
LegacyResolver = LegacyResolver;
|
|
|
|
init(props) {
|
|
super.init(props);
|
|
this.legacyResolver = this.LegacyResolver.create(props);
|
|
}
|
|
|
|
resolveRouter(/* parsedName */) {
|
|
const routerPath = `${baseName}/router`;
|
|
if (requirejs.entries[routerPath]) {
|
|
const module = requirejs(routerPath, null, null, true);
|
|
return module.default;
|
|
}
|
|
}
|
|
|
|
// We overwrite this instead of `normalize` so we still get the benefits of the cache.
|
|
_normalize(fullName) {
|
|
if (fullName === "app-events:main") {
|
|
deprecated(
|
|
"`app-events:main` has been replaced with `service:app-events`",
|
|
{ since: "2.4.0", dropFrom: "2.9.0.beta1" }
|
|
);
|
|
fullName = "service:app-events";
|
|
}
|
|
|
|
for (const [key, value] of Object.entries({
|
|
"controller:discovery.categoryWithID": "controller:discovery.category",
|
|
"controller:discovery.parentCategory": "controller:discovery.category",
|
|
"controller:tags-show": "controller:tag-show",
|
|
"controller:tags.show": "controller:tag.show",
|
|
"controller:tagsShow": "controller:tagShow",
|
|
"route:discovery.categoryWithID": "route:discovery.category",
|
|
"route:discovery.parentCategory": "route:discovery.category",
|
|
"route:tags-show": "route:tag-show",
|
|
"route:tags.show": "route:tag.show",
|
|
"route:tagsShow": "route:tagShow",
|
|
})) {
|
|
if (fullName === key) {
|
|
deprecated(`${key} was replaced with ${value}`, { since: "2.6.0" });
|
|
fullName = value;
|
|
}
|
|
}
|
|
|
|
const split = fullName.split(":");
|
|
const type = split[0];
|
|
|
|
let normalized;
|
|
if (type === "template" && split[1]?.includes("connectors/")) {
|
|
// The default normalize implementation will skip dasherizing component template names
|
|
// We need the same for our connector templates names
|
|
normalized = "template:" + split[1].replace(/_/g, "-");
|
|
} else {
|
|
normalized = super._normalize(fullName);
|
|
}
|
|
|
|
// This is code that we don't really want to keep long term. The main situation where we need it is for
|
|
// doing stuff like `controllerFor('adminWatchedWordsAction')` where the real route name
|
|
// is actually `adminWatchedWords.action`. The default behavior for the former is to
|
|
// normalize to `adminWatchedWordsAction` where the latter becomes `adminWatchedWords.action`.
|
|
// While these end up looking up the same file ultimately, they are treated as different
|
|
// items and so we can end up with two distinct version of the controller!
|
|
if (
|
|
split.length > 1 &&
|
|
(type === "controller" || type === "route" || type === "template")
|
|
) {
|
|
let corrected;
|
|
// This should only apply when there's a dot or slash in the name
|
|
if (split[1].includes(".") || split[1].includes("/")) {
|
|
// Check to see if the dasherized version exists. If it does we want to
|
|
// normalize to that eagerly so the normalized versions of the dotted/slashed and
|
|
// dotless/slashless match.
|
|
const dashed = dasherize(split[1].replace(/[\.\/]/g, "-"));
|
|
|
|
const adminBase = `admin/${type}s/`;
|
|
const wizardBase = `wizard/${type}s/`;
|
|
if (
|
|
lookupModuleBySuffix(`${type}s/${dashed}`) ||
|
|
requirejs.entries[adminBase + dashed] ||
|
|
requirejs.entries[adminBase + dashed.replace(/^admin[-]/, "")] ||
|
|
requirejs.entries[
|
|
adminBase + dashed.replace(/^admin[-]/, "").replace(/-/g, "_")
|
|
] ||
|
|
requirejs.entries[wizardBase + dashed] ||
|
|
requirejs.entries[wizardBase + dashed.replace(/^wizard[-]/, "")] ||
|
|
requirejs.entries[
|
|
wizardBase + dashed.replace(/^wizard[-]/, "").replace(/-/g, "_")
|
|
]
|
|
) {
|
|
corrected = type + ":" + dashed;
|
|
}
|
|
}
|
|
|
|
if (corrected && corrected !== normalized) {
|
|
normalized = corrected;
|
|
}
|
|
}
|
|
|
|
return normalized;
|
|
}
|
|
|
|
chooseModuleName(moduleName, parsedName) {
|
|
let resolved = super.chooseModuleName(moduleName, parsedName);
|
|
if (resolved) {
|
|
return resolved;
|
|
}
|
|
|
|
const standard = parsedName.fullNameWithoutType;
|
|
|
|
let variants = [standard];
|
|
|
|
if (standard.includes("/")) {
|
|
variants.push(parsedName.fullNameWithoutType.replace(/\//g, "-"));
|
|
}
|
|
|
|
for (let name of variants) {
|
|
// If we end with the name we want, use it. This allows us to define components within plugins.
|
|
const suffix = parsedName.type + "s/" + name;
|
|
resolved = lookupModuleBySuffix(dasherize(suffix));
|
|
if (resolved) {
|
|
return resolved;
|
|
}
|
|
}
|
|
}
|
|
|
|
resolveOther(parsedName) {
|
|
let resolved = super.resolveOther(parsedName);
|
|
if (!resolved) {
|
|
let legacyParsedName = this.legacyResolver.parseName(
|
|
`${parsedName.type}:${parsedName.fullName}`
|
|
);
|
|
resolved = this.legacyResolver.resolveOther(legacyParsedName);
|
|
if (resolved) {
|
|
deprecated(
|
|
`Unable to resolve with new resolver, but resolved with legacy resolver: ${parsedName.fullName}`
|
|
);
|
|
}
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
resolveHelper(parsedName) {
|
|
return findHelper(parsedName.fullNameWithoutType);
|
|
}
|
|
|
|
// If no match is found here, the resolver falls back to `resolveOther`.
|
|
resolveRoute(parsedName) {
|
|
if (parsedName.fullNameWithoutType === "basic") {
|
|
return requirejs("discourse/routes/discourse", null, null, true)
|
|
.default;
|
|
}
|
|
}
|
|
|
|
resolveTemplate(parsedName) {
|
|
return (
|
|
this.findPluginMobileTemplate(parsedName) ||
|
|
this.findPluginTemplate(parsedName) ||
|
|
this.findMobileTemplate(parsedName) ||
|
|
this.findTemplate(parsedName) ||
|
|
this.findAdminTemplate(parsedName) ||
|
|
this.findWizardTemplate(parsedName) ||
|
|
this.findLoadingTemplate(parsedName) ||
|
|
this.findConnectorTemplate(parsedName) ||
|
|
Ember.TEMPLATES.not_found
|
|
);
|
|
}
|
|
|
|
findLoadingTemplate(parsedName) {
|
|
if (parsedName.fullNameWithoutType.match(/loading$/)) {
|
|
return Ember.TEMPLATES.loading;
|
|
}
|
|
}
|
|
|
|
findConnectorTemplate(parsedName) {
|
|
if (parsedName.fullName.startsWith("template:connectors/")) {
|
|
const connectorParsedName = this.parseName(
|
|
parsedName.fullName
|
|
.replace("template:connectors/", "template:")
|
|
.replace("components/", "")
|
|
);
|
|
return this.findTemplate(connectorParsedName, "javascripts/");
|
|
}
|
|
}
|
|
|
|
findPluginTemplate(parsedName) {
|
|
return this.findTemplate(parsedName, "javascripts/");
|
|
}
|
|
|
|
findPluginMobileTemplate(parsedName) {
|
|
if (_options.mobileView) {
|
|
return this.findTemplate(parsedName, "javascripts/mobile/");
|
|
}
|
|
}
|
|
|
|
findMobileTemplate(parsedName) {
|
|
if (_options.mobileView) {
|
|
return this.findTemplate(parsedName, "mobile/");
|
|
}
|
|
}
|
|
|
|
findTemplate(parsedName, prefix) {
|
|
prefix = prefix || "";
|
|
|
|
const withoutType = parsedName.fullNameWithoutType,
|
|
underscored = decamelize(withoutType).replace(/-/g, "_"),
|
|
segments = withoutType.split("/"),
|
|
templates = Ember.TEMPLATES;
|
|
|
|
return (
|
|
// Convert dots and dashes to slashes
|
|
templates[prefix + withoutType.replace(/[\.-]/g, "/")] ||
|
|
// Default unmodified behavior of original resolveTemplate.
|
|
templates[prefix + withoutType] ||
|
|
// Underscored without namespace
|
|
templates[prefix + underscored] ||
|
|
// Underscored with first segment as directory
|
|
templates[prefix + underscored.replace("_", "/")] ||
|
|
// Underscore only the last segment
|
|
templates[
|
|
`${prefix}${segments.slice(0, -1).join("/")}/${segments[
|
|
segments.length - 1
|
|
].replace(/-/g, "_")}`
|
|
] ||
|
|
// All dasherized
|
|
templates[prefix + withoutType.replace(/\//g, "-")]
|
|
);
|
|
}
|
|
|
|
// Try to find a template within a special admin namespace, e.g. adminEmail => admin/templates/email
|
|
// (similar to how discourse lays out templates)
|
|
findAdminTemplate(parsedName) {
|
|
if (parsedName.fullNameWithoutType === "admin") {
|
|
return Ember.TEMPLATES["admin/templates/admin"];
|
|
}
|
|
|
|
let namespaced, match;
|
|
|
|
if (parsedName.fullNameWithoutType.startsWith("components/")) {
|
|
// Look up components as-is
|
|
} else if (/^admin[_\.-]/.test(parsedName.fullNameWithoutType)) {
|
|
namespaced = parsedName.fullNameWithoutType.slice(6);
|
|
} else if (
|
|
(match = parsedName.fullNameWithoutType.match(/^admin([A-Z])(.+)$/))
|
|
) {
|
|
namespaced = `${match[1].toLowerCase()}${match[2]}`;
|
|
}
|
|
|
|
let resolved;
|
|
|
|
if (namespaced) {
|
|
let adminParsedName = this.parseName(`template:${namespaced}`);
|
|
resolved =
|
|
// Built-in
|
|
this.findTemplate(adminParsedName, "admin/templates/") ||
|
|
// Plugin
|
|
this.findTemplate(adminParsedName, "javascripts/admin/");
|
|
}
|
|
|
|
resolved ??=
|
|
// Built-in
|
|
this.findTemplate(parsedName, "admin/templates/") ||
|
|
// Plugin
|
|
this.findTemplate(parsedName, "javascripts/admin/");
|
|
|
|
return resolved;
|
|
}
|
|
|
|
findWizardTemplate(parsedName) {
|
|
if (parsedName.fullNameWithoutType === "wizard") {
|
|
return Ember.TEMPLATES["wizard/templates/wizard"];
|
|
}
|
|
|
|
let namespaced;
|
|
|
|
if (parsedName.fullNameWithoutType.startsWith("components/")) {
|
|
// Look up components as-is
|
|
namespaced = parsedName.fullNameWithoutType;
|
|
} else if (/^wizard[_\.-]/.test(parsedName.fullNameWithoutType)) {
|
|
// This may only get hit for the loading routes and may be removable.
|
|
namespaced = parsedName.fullNameWithoutType.slice(7);
|
|
}
|
|
|
|
if (namespaced) {
|
|
let adminParsedName = this.parseName(
|
|
`template:wizard/templates/${namespaced}`
|
|
);
|
|
return this.findTemplate(adminParsedName);
|
|
}
|
|
}
|
|
};
|
|
}
|