source: frontend/node_modules/webpack/lib/dependencies/AMDPlugin.js

Last change on this file was 9af201e, checked in by MBK <marija.karapandzova@…>, 12 days ago

Fix frontend appearance
  • Property mode set to 100644
File size: 7.4 KB
RevLine 
[9af201e]1/*
2 MIT License http://www.opensource.org/licenses/mit-license.php
3 Author Tobias Koppers @sokra
4*/
5
6"use strict";
7
8const {
9 JAVASCRIPT_MODULE_TYPE_AUTO,
10 JAVASCRIPT_MODULE_TYPE_DYNAMIC
11} = require("../ModuleTypeConstants");
12const RuntimeGlobals = require("../RuntimeGlobals");
13const {
14 approve,
15 evaluateToIdentifier,
16 evaluateToString,
17 toConstantDependency
18} = require("../javascript/JavascriptParserHelpers");
19
20const AMDDefineDependency = require("./AMDDefineDependency");
21const AMDDefineDependencyParserPlugin = require("./AMDDefineDependencyParserPlugin");
22const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
23const AMDRequireContextDependency = require("./AMDRequireContextDependency");
24const AMDRequireDependenciesBlockParserPlugin = require("./AMDRequireDependenciesBlockParserPlugin");
25const AMDRequireDependency = require("./AMDRequireDependency");
26const AMDRequireItemDependency = require("./AMDRequireItemDependency");
27const {
28 AMDDefineRuntimeModule,
29 AMDOptionsRuntimeModule
30} = require("./AMDRuntimeModules");
31const ConstDependency = require("./ConstDependency");
32const LocalModuleDependency = require("./LocalModuleDependency");
33const UnsupportedDependency = require("./UnsupportedDependency");
34
35/** @typedef {import("../../declarations/WebpackOptions").Amd} Amd */
36/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
37/** @typedef {import("../Compiler")} Compiler */
38/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
39/** @typedef {import("../javascript/JavascriptParser")} Parser */
40/** @typedef {import("../javascript/JavascriptParser").Range} Range */
41/** @typedef {import("../javascript/BasicEvaluatedExpression").GetMembers} GetMembers */
42
43const PLUGIN_NAME = "AMDPlugin";
44
45/** @typedef {Exclude<Amd, false>} AmdOptions */
46
47class AMDPlugin {
48 /**
49 * Creates an instance of AMDPlugin.
50 * @param {AmdOptions} amdOptions the AMD options
51 */
52 constructor(amdOptions) {
53 this.amdOptions = amdOptions;
54 }
55
56 /**
57 * Applies the plugin by registering its hooks on the compiler.
58 * @param {Compiler} compiler the compiler instance
59 * @returns {void}
60 */
61 apply(compiler) {
62 const { amdOptions } = this;
63 compiler.hooks.compilation.tap(
64 PLUGIN_NAME,
65 (compilation, { contextModuleFactory, normalModuleFactory }) => {
66 compilation.dependencyTemplates.set(
67 AMDRequireDependency,
68 new AMDRequireDependency.Template()
69 );
70
71 compilation.dependencyFactories.set(
72 AMDRequireItemDependency,
73 normalModuleFactory
74 );
75 compilation.dependencyTemplates.set(
76 AMDRequireItemDependency,
77 new AMDRequireItemDependency.Template()
78 );
79
80 compilation.dependencyTemplates.set(
81 AMDRequireArrayDependency,
82 new AMDRequireArrayDependency.Template()
83 );
84
85 compilation.dependencyFactories.set(
86 AMDRequireContextDependency,
87 contextModuleFactory
88 );
89 compilation.dependencyTemplates.set(
90 AMDRequireContextDependency,
91 new AMDRequireContextDependency.Template()
92 );
93
94 compilation.dependencyTemplates.set(
95 AMDDefineDependency,
96 new AMDDefineDependency.Template()
97 );
98
99 compilation.dependencyTemplates.set(
100 UnsupportedDependency,
101 new UnsupportedDependency.Template()
102 );
103
104 compilation.dependencyTemplates.set(
105 LocalModuleDependency,
106 new LocalModuleDependency.Template()
107 );
108
109 compilation.hooks.runtimeRequirementInModule
110 .for(RuntimeGlobals.amdDefine)
111 .tap(PLUGIN_NAME, (module, set) => {
112 set.add(RuntimeGlobals.require);
113 });
114
115 compilation.hooks.runtimeRequirementInModule
116 .for(RuntimeGlobals.amdOptions)
117 .tap(PLUGIN_NAME, (module, set) => {
118 set.add(RuntimeGlobals.requireScope);
119 });
120
121 compilation.hooks.runtimeRequirementInTree
122 .for(RuntimeGlobals.amdDefine)
123 .tap(PLUGIN_NAME, (chunk, _set) => {
124 compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
125 });
126
127 compilation.hooks.runtimeRequirementInTree
128 .for(RuntimeGlobals.amdOptions)
129 .tap(PLUGIN_NAME, (chunk, _set) => {
130 compilation.addRuntimeModule(
131 chunk,
132 new AMDOptionsRuntimeModule(amdOptions)
133 );
134 });
135
136 /**
137 * Handles the hook callback for this code path.
138 * @param {Parser} parser parser parser
139 * @param {JavascriptParserOptions} parserOptions parserOptions
140 * @returns {void}
141 */
142 const handler = (parser, parserOptions) => {
143 if (parserOptions.amd !== undefined && !parserOptions.amd) return;
144
145 /**
146 * Processes the provided option expr.
147 * @param {string} optionExpr option expression
148 * @param {string} rootName root name
149 * @param {GetMembers} getMembers callback
150 */
151 const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
152 parser.hooks.expression
153 .for(optionExpr)
154 .tap(
155 PLUGIN_NAME,
156 toConstantDependency(parser, RuntimeGlobals.amdOptions, [
157 RuntimeGlobals.amdOptions
158 ])
159 );
160 parser.hooks.evaluateIdentifier
161 .for(optionExpr)
162 .tap(PLUGIN_NAME, (expr) =>
163 evaluateToIdentifier(
164 optionExpr,
165 rootName,
166 getMembers,
167 true
168 )(expr)
169 );
170 parser.hooks.evaluateTypeof
171 .for(optionExpr)
172 .tap(PLUGIN_NAME, evaluateToString("object"));
173 parser.hooks.typeof
174 .for(optionExpr)
175 .tap(
176 PLUGIN_NAME,
177 toConstantDependency(parser, JSON.stringify("object"))
178 );
179 };
180
181 new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
182 parser
183 );
184 new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
185
186 tapOptionsHooks("define.amd", "define", () => ["amd"]);
187 tapOptionsHooks("require.amd", "require", () => ["amd"]);
188 tapOptionsHooks(
189 "__webpack_amd_options__",
190 "__webpack_amd_options__",
191 () => []
192 );
193
194 parser.hooks.expression.for("define").tap(PLUGIN_NAME, (expr) => {
195 const dep = new ConstDependency(
196 RuntimeGlobals.amdDefine,
197 /** @type {Range} */ (expr.range),
198 [RuntimeGlobals.amdDefine]
199 );
200 dep.loc = /** @type {DependencyLocation} */ (expr.loc);
201 parser.state.module.addPresentationalDependency(dep);
202 return true;
203 });
204 parser.hooks.typeof
205 .for("define")
206 .tap(
207 PLUGIN_NAME,
208 toConstantDependency(parser, JSON.stringify("function"))
209 );
210 parser.hooks.evaluateTypeof
211 .for("define")
212 .tap(PLUGIN_NAME, evaluateToString("function"));
213 parser.hooks.canRename.for("define").tap(PLUGIN_NAME, approve);
214 parser.hooks.rename.for("define").tap(PLUGIN_NAME, (expr) => {
215 const dep = new ConstDependency(
216 RuntimeGlobals.amdDefine,
217 /** @type {Range} */ (expr.range),
218 [RuntimeGlobals.amdDefine]
219 );
220 dep.loc = /** @type {DependencyLocation} */ (expr.loc);
221 parser.state.module.addPresentationalDependency(dep);
222 return false;
223 });
224 parser.hooks.typeof
225 .for("require")
226 .tap(
227 PLUGIN_NAME,
228 toConstantDependency(parser, JSON.stringify("function"))
229 );
230 parser.hooks.evaluateTypeof
231 .for("require")
232 .tap(PLUGIN_NAME, evaluateToString("function"));
233 };
234
235 normalModuleFactory.hooks.parser
236 .for(JAVASCRIPT_MODULE_TYPE_AUTO)
237 .tap(PLUGIN_NAME, handler);
238 normalModuleFactory.hooks.parser
239 .for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
240 .tap(PLUGIN_NAME, handler);
241 }
242 );
243 }
244}
245
246module.exports = AMDPlugin;
Note: See TracBrowser for help on using the repository browser.