@ui5/webcomponents-base 0.0.0-c6155714e → 0.0.0-c638668a1

package/dist/test-resources/specs/UI5ElementMetadataExt.js

@@ -1,11 +1,13 @@
 const assert = require("chai").assert;
 
 describe("Metadata can be extended", () => {
-	browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	before(async () => {
+		await browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	});
 
-	it("When extending metadata, both own and extended entities exist in the resulting metadata", () => {
+	it("When extending metadata, both own and extended entities exist in the resulting metadata", async () => {
 
-		const res = browser.execute( () => {
+		const res = await browser.executeAsync(done => {
 
 			const el = document.getElementById("genExt");
 			const m = el.constructor.getMetadata();
@@ -15,15 +17,15 @@ describe("Metadata can be extended", () => {
 				!!m.getSlots().default &&
 				!!m.getSlots().extSlot;
 
-			return ok;
+			done(ok);
 		});
 
 		assert.strictEqual(res, true, "Metadata properly extended");
 	});
 
-	it("When extending metadata, property defaultValue can be modified", () => {
+	it("When extending metadata, property defaultValue can be modified", async () => {
 
-		const res = browser.execute( () => {
+		const res = await browser.executeAsync(done => {
 
 			const el = document.getElementById("genExt");
 			const m = el.constructor.getMetadata();
@@ -31,7 +33,7 @@ describe("Metadata can be extended", () => {
 			const ok = !!m.getProperties().strProp &&
 				m.getProperties().strProp.defaultValue === "Ext";
 
-			return ok;
+			done(ok);
 		});
 
 		assert.strictEqual(res, true, "Property defaultValue changed");

package/dist/test-resources/specs/UI5ElementPropertyValidation.js

@@ -1,12 +1,14 @@
 const assert = require("chai").assert;
 
 describe("Properties can only have values, restricted to their types", () => {
-	browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	before(async () => {
+		await browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	});
 
-	it("String property enforced to string", () => {
-		const el = browser.$("#gen");
-		el.setProperty("strProp", 5);
-		assert.strictEqual(el.getProperty("strProp"), "5", "String property is string");
+	it("String property enforced to string", async () => {
+		const el = await browser.$("#gen");
+		await el.setProperty("strProp", 5);
+		assert.strictEqual(await el.getProperty("strProp"), "5", "String property is string");
 	});
 
 });

package/dist/test-resources/specs/UI5ElementPropsAndAttrs.spec.js

@@ -1,65 +1,67 @@
 const assert = require("chai").assert;
 
 describe("Properties and attributes convert to each other", () => {
-	browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	before(async () => {
+		await browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	});
 
-	it("Tests that properties with default values are initialized with the default value", () => {
-		const el = browser.$("#gen");
+	it("Tests that properties with default values are initialized with the default value", async () => {
+		const el = await browser.$("#gen");
 
-		assert.strictEqual(el.getProperty("defaultValueProp"), "Hello", "defaultValueProp is properly initialized");
+		assert.strictEqual(await el.getProperty("defaultValueProp"), "Hello", "defaultValueProp is properly initialized");
 	});
 
-	it("Tests that prop-attr conversion works for string properties", () => {
-		const el = browser.$("#gen");
+	it("Tests that prop-attr conversion works for string properties", async () => {
+		const el = await browser.$("#gen");
 
-		el.setProperty("strProp", "test1");
-		assert.strictEqual(el.getAttribute("str-prop"), "test1", "Attribute affected by property change");
+		await el.setProperty("strProp", "test1");
+		assert.strictEqual(await el.getAttribute("str-prop"), "test1", "Attribute affected by property change");
 
-		el.setAttribute("str-prop", "test2");
-		assert.strictEqual(el.getProperty("strProp"), "test2", "Property affected by attribute change");
+		await el.setAttribute("str-prop", "test2");
+		assert.strictEqual(await el.getProperty("strProp"), "test2", "Property affected by attribute change");
 	});
 
-	it("Tests that prop-attr conversion works for boolean properties", () => {
-		const el = browser.$("#gen");
+	it("Tests that prop-attr conversion works for boolean properties", async () => {
+		const el = await browser.$("#gen");
 
-		el.setProperty("boolProp", true);
-		assert.strictEqual(el.getAttribute("bool-prop"), "", "Attribute affected by property change");
+		await el.setProperty("boolProp", true);
+		assert.strictEqual(await el.getAttribute("bool-prop"), "", "Attribute affected by property change");
 
-		el.setProperty("boolProp", false);
-		assert.strictEqual(el.getAttribute("bool-prop"), null, "Attribute affected by property change");
+		await el.setProperty("boolProp", false);
+		assert.strictEqual(await el.getAttribute("bool-prop"), null, "Attribute affected by property change");
 
-		el.setAttribute("bool-prop", "");
-		assert.strictEqual(el.getProperty("boolProp"), true, "Property affected by attribute change");
+		await el.setAttribute("bool-prop", "");
+		assert.strictEqual(await el.getProperty("boolProp"), true, "Property affected by attribute change");
 
-		el.removeAttribute("bool-prop");
-		assert.strictEqual(el.getProperty("boolProp"), false, "Property affected by attribute change");
+		await el.removeAttribute("bool-prop");
+		assert.strictEqual(await el.getProperty("boolProp"), false, "Property affected by attribute change");
 	});
 
-	it("Tests that object properties have no attributes", () => {
-		const el = browser.$("#gen");
+	it("Tests that object properties have no attributes", async () => {
+		const el = await browser.$("#gen");
 
-		el.setProperty("objectProp", {});
-		assert.strictEqual(el.getAttribute("object-prop"), null, "Attribute not there");
+		await el.setProperty("objectProp", {});
+		assert.strictEqual(await el.getAttribute("object-prop"), null, "Attribute not there");
 	});
 
-	it("Tests that array properties have no attributes", () => {
-		const el = browser.$("#gen");
+	it("Tests that array properties have no attributes", async () => {
+		const el = await browser.$("#gen");
 
-		el.setProperty("multiProp", ["a", "b"]);
-		assert.strictEqual(el.getAttribute("multi-prop"), null, "Attribute not there");
+		await el.setProperty("multiProp", ["a", "b"]);
+		assert.strictEqual(await el.getAttribute("multi-prop"), null, "Attribute not there");
 	});
 
-	it("Tests that noAttribute properties have no attributes", () => {
-		const el = browser.$("#gen");
+	it("Tests that noAttribute properties have no attributes", async () => {
+		const el = await browser.$("#gen");
 
-		el.setProperty("noAttributeProp", "some value");
-		assert.strictEqual(el.getAttribute("no-attribute-prop"), null, "Attribute not there");
+		await el.setProperty("noAttributeProp", "some value");
+		assert.strictEqual(await el.getAttribute("no-attribute-prop"), null, "Attribute not there");
 	});
 
-	it("Tests that properties with default values do not automatically set attributes", () => {
-		const el = browser.$("#gen");
+	it("Tests that properties with default values do not automatically set attributes", async () => {
+		const el = await browser.$("#gen");
 
-		assert.strictEqual(el.getAttribute("default-value-prop"), null, "Attribute not there for defaultValueProp");
+		assert.strictEqual(await el.getAttribute("default-value-prop"), null, "Attribute not there for defaultValueProp");
 	});
 
 });

package/dist/test-resources/specs/UI5ElementShadowDOM.js

@@ -1,20 +1,22 @@
 const assert = require("chai").assert;
 
 describe("The framework can define web components", () => {
-	browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	before(async () => {
+		await browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	});
 
-	it("Tests that element's Shadow DOM is rendered if it has a template", () => {
-		const res = browser.execute(() => {
-			return document.getElementById("gen").shadowRoot;
+	it("Tests that element's Shadow DOM is rendered if it has a template", async () => {
+		const res = await browser.executeAsync(done => {
+			done(document.getElementById("gen").shadowRoot);
 		});
 
 		assert.strictEqual(!!res, true, "Shadow root created");
-		assert.strictEqual(browser.$("#gen").shadow$("div>p").isExisting(), true, "Shadow root content created");
+		assert.strictEqual(await browser.$("#gen").shadow$("div>p").isExisting(), true, "Shadow root content created");
 	});
 
-	it("Tests that element's Shadow DOM is not rendered if it has no template", () => {
-		const res = browser.execute(() => {
-			return document.getElementById("noShadow").shadowRoot;
+	it("Tests that element's Shadow DOM is not rendered if it has no template", async () => {
+		const res = await browser.executeAsync(done => {
+			done(document.getElementById("noShadow").shadowRoot);
 		});
 
 		assert.strictEqual(!!res, false, "Shadow root not created");

package/dist/test-resources/specs/UI5ElementSlots.js

@@ -1,10 +1,12 @@
 const assert = require("chai").assert;
 
 describe("Slots work properly", () => {
-	browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	before(async () => {
+		await browser.url("http://localhost:9191/test-resources/pages/AllTestElements.html");
+	});
 
-	it("Tests that properties exist on the element for each slot", () => {
-		const res = browser.execute(() => {
+	it("Tests that properties exist on the element for each slot", async () => {
+		const res = await browser.executeAsync(done => {
 			const expectedValues = {};
 
 			const el = document.getElementById("withContent");
@@ -15,7 +17,7 @@ describe("Slots work properly", () => {
 			expectedValues.items = el.items.length === 2;
 			expectedValues.named = el.named === undefined;
 
-			return expectedValues;
+			done(expectedValues);
 		});
 
 		assert.strictEqual(res.default, true, "There are elements in the default property");
@@ -25,10 +27,10 @@ describe("Slots work properly", () => {
 		assert.strictEqual(res.named, true, "There is no named property as propertyName changed it to items");
 	});
 
-	it("Tests that individualSlots modifies the slot property of slotted children", () => {
-		assert.strictEqual(browser.$$("#withContent>[slot=individual]").length, 0, "There are no children with slot=individual");
-		assert.strictEqual(browser.$$("#withContent>[slot=individual-1]").length, 1, "The slot of the first child became individual-1");
-		assert.strictEqual(browser.$$("#withContent>[slot=individual-2]").length, 1, "The slot of the second child became individual-2");
+	it("Tests that individualSlots modifies the slot property of slotted children", async () => {
+		assert.strictEqual((await browser.$$("#withContent>[slot=individual]")).length, 0, "There are no children with slot=individual");
+		assert.strictEqual((await browser.$$("#withContent>[slot=individual-1]")).length, 1, "The slot of the first child became individual-1");
+		assert.strictEqual((await browser.$$("#withContent>[slot=individual-2]")).length, 1, "The slot of the second child became individual-2");
 	});
 
 });

package/dist/theming/CustomStyle.js

@@ -1,19 +1,60 @@
-const customCSSFor = {};
+import { reRenderAllUI5Elements } from "../Render.js";
+import getSharedResource from "../getSharedResource.js";
+import EventProvider from "../EventProvider.js";
 
-const addCustomCSS = (tag, css, ...rest) => {
-	if (rest.length) {
-		throw new Error("addCustomCSS no longer accepts theme specific CSS. new signature is `addCustomCSS(tag, css)`");
+const eventProvider = getSharedResource("CustomStyle.eventProvider", new EventProvider());
+const CUSTOM_CSS_CHANGE = "CustomCSSChange";
+
+const attachCustomCSSChange = listener => {
+	eventProvider.attachEvent(CUSTOM_CSS_CHANGE, listener);
+};
+
+const detachCustomCSSChange = listener => {
+	eventProvider.detachEvent(CUSTOM_CSS_CHANGE, listener);
+};
+
+const fireCustomCSSChange = tag => {
+	return eventProvider.fireEvent(CUSTOM_CSS_CHANGE, tag);
+};
+
+const customCSSFor = getSharedResource("CustomStyle.customCSSFor", {});
+
+// Listen to the eventProvider, in case other copies of this CustomStyle module fire this
+// event, and this copy would therefore need to reRender the ui5 webcomponents; but
+// don't reRender if it was this copy that fired the event to begin with.
+let skipRerender;
+attachCustomCSSChange(tag => {
+	if (!skipRerender) {
+		reRenderAllUI5Elements({ tag });
 	}
+});
 
+const addCustomCSS = (tag, css) => {
 	if (!customCSSFor[tag]) {
 		customCSSFor[tag] = [];
 	}
-
 	customCSSFor[tag].push(css);
+
+	skipRerender = true;
+	try {
+		// The event is fired and the attached event listeners are all called synchronously
+		// The skipRerender flag will be used to avoid calling reRenderAllUI5Elements twice when it is this copy
+		// of CustomStyle.js which is firing the `CustomCSSChange` event.
+		fireCustomCSSChange(tag);
+	} finally {
+		skipRerender = false;
+	}
+
+	return reRenderAllUI5Elements({ tag });
 };
 
 const getCustomCSS = tag => {
 	return customCSSFor[tag] ? customCSSFor[tag].join("") : "";
 };
 
-export { addCustomCSS, getCustomCSS };
+export {
+	addCustomCSS,
+	getCustomCSS,
+	attachCustomCSSChange,
+	detachCustomCSSChange,
+};

package/dist/theming/ThemeLoaded.js

@@ -0,0 +1,22 @@
+import EventProvider from "../EventProvider.js";
+
+const eventProvider = new EventProvider();
+const THEME_LOADED = "themeLoaded";
+
+const attachThemeLoaded = listener => {
+	eventProvider.attachEvent(THEME_LOADED, listener);
+};
+
+const detachThemeLoaded = listener => {
+	eventProvider.detachEvent(THEME_LOADED, listener);
+};
+
+const fireThemeLoaded = theme => {
+	return eventProvider.fireEvent(THEME_LOADED, theme);
+};
+
+export {
+	attachThemeLoaded,
+	detachThemeLoaded,
+	fireThemeLoaded,
+};

package/dist/theming/applyTheme.js

@@ -0,0 +1,79 @@
+import { getThemeProperties, getRegisteredPackages, isThemeRegistered } from "../asset-registries/Themes.js";
+import { removeStyle, createOrUpdateStyle } from "../ManagedStyles.js";
+import getThemeDesignerTheme from "./getThemeDesignerTheme.js";
+import { fireThemeLoaded } from "./ThemeLoaded.js";
+import { getFeature } from "../FeaturesRegistry.js";
+
+const BASE_THEME_PACKAGE = "@ui5/webcomponents-theming";
+
+const isThemeBaseRegistered = () => {
+	const registeredPackages = getRegisteredPackages();
+	return registeredPackages.has(BASE_THEME_PACKAGE);
+};
+
+const loadThemeBase = async theme => {
+	if (!isThemeBaseRegistered()) {
+		return;
+	}
+
+	const cssData = await getThemeProperties(BASE_THEME_PACKAGE, theme);
+	if (cssData) {
+		createOrUpdateStyle(cssData, "data-ui5-theme-properties", BASE_THEME_PACKAGE);
+	}
+};
+
+const deleteThemeBase = () => {
+	removeStyle("data-ui5-theme-properties", BASE_THEME_PACKAGE);
+};
+
+const loadComponentPackages = async theme => {
+	const registeredPackages = getRegisteredPackages();
+	registeredPackages.forEach(async packageName => {
+		if (packageName === BASE_THEME_PACKAGE) {
+			return;
+		}
+
+		const cssData = await getThemeProperties(packageName, theme);
+		if (cssData) {
+			createOrUpdateStyle(cssData, "data-ui5-theme-properties", packageName);
+		}
+	});
+};
+
+const detectExternalTheme = () => {
+	// If theme designer theme is detected, use this
+	const extTheme = getThemeDesignerTheme();
+	if (extTheme) {
+		return extTheme;
+	}
+
+	// If OpenUI5Support is enabled, try to find out if it loaded variables
+	const OpenUI5Support = getFeature("OpenUI5Support");
+	if (OpenUI5Support) {
+		const varsLoaded = OpenUI5Support.cssVariablesLoaded();
+		if (varsLoaded) {
+			return {
+				themeName: OpenUI5Support.getConfigurationSettingsObject().theme, // just themeName, baseThemeName is only relevant for custom themes
+			};
+		}
+	}
+};
+
+const applyTheme = async theme => {
+	const extTheme = detectExternalTheme();
+
+	// Only load theme_base properties if there is no externally loaded theme, or there is, but it is not being loaded
+	if (!extTheme || theme !== extTheme.themeName) {
+		await loadThemeBase(theme);
+	} else {
+		deleteThemeBase();
+	}
+
+	// Always load component packages properties. For non-registered themes, try with the base theme, if any
+	const packagesTheme = isThemeRegistered(theme) ? theme : extTheme && extTheme.baseThemeName;
+	await loadComponentPackages(packagesTheme);
+
+	fireThemeLoaded(theme);
+};
+
+export default applyTheme;

package/dist/theming/getConstructableStyle.js

@@ -0,0 +1,30 @@
+import getEffectiveStyle from "./getEffectiveStyle.js";
+import { attachCustomCSSChange } from "./CustomStyle.js";
+
+const constructableStyleMap = new Map();
+
+attachCustomCSSChange(tag => {
+	constructableStyleMap.delete(`${tag}_normal`); // there is custom CSS only for the component itself, not for its static area part
+});
+
+/**
+ * Returns (and caches) a constructable style sheet for a web component class
+ * Note: Chrome
+ * @param ElementClass
+ * @returns {*}
+ */
+const getConstructableStyle = (ElementClass, forStaticArea = false) => {
+	const tag = ElementClass.getMetadata().getTag();
+	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
+
+	if (!constructableStyleMap.has(key)) {
+		const styleContent = getEffectiveStyle(ElementClass, forStaticArea);
+		const style = new CSSStyleSheet();
+		style.replaceSync(styleContent);
+		constructableStyleMap.set(key, [style]);
+	}
+
+	return constructableStyleMap.get(key);
+};
+
+export default getConstructableStyle;

package/dist/theming/getEffectiveLinksHrefs.js

@@ -0,0 +1,20 @@
+import { getUrl } from "../CSP.js";
+
+const flatten = arr => {
+	return arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val), []);
+};
+
+const getEffectiveLinksHrefs = (ElementClass, forStaticArea = false) => {
+	let stylesData = ElementClass[forStaticArea ? "staticAreaStyles" : "styles"];
+	if (!stylesData) {
+		return;
+	}
+
+	if (!Array.isArray(stylesData)) {
+		stylesData = [stylesData];
+	}
+
+	return flatten(stylesData).filter(data => !!data).map(data => getUrl(data.packageName, data.fileName));
+};
+
+export default getEffectiveLinksHrefs;

package/dist/theming/getEffectiveStyle.js

@@ -0,0 +1,30 @@
+import { getCustomCSS, attachCustomCSSChange } from "./CustomStyle.js";
+import getStylesString from "./getStylesString.js";
+
+const effectiveStyleMap = new Map();
+
+attachCustomCSSChange(tag => {
+	effectiveStyleMap.delete(`${tag}_normal`); // there is custom CSS only for the component itself, not for its static area part
+});
+
+const getEffectiveStyle = (ElementClass, forStaticArea = false) => {
+	const tag = ElementClass.getMetadata().getTag();
+	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
+
+	if (!effectiveStyleMap.has(key)) {
+		let effectiveStyle;
+
+		if (forStaticArea) {
+			effectiveStyle = getStylesString(ElementClass.staticAreaStyles);
+		} else {
+			const customStyle = getCustomCSS(tag) || "";
+			const builtInStyles = getStylesString(ElementClass.styles);
+			effectiveStyle = `${builtInStyles} ${customStyle}`;
+		}
+		effectiveStyleMap.set(key, effectiveStyle);
+	}
+
+	return effectiveStyleMap.get(key);
+};
+
+export default getEffectiveStyle;

package/dist/theming/getStylesString.js

@@ -0,0 +1,15 @@
+const getStylesString = styles => {
+	if (Array.isArray(styles)) {
+		return flatten(styles.filter(style => !!style)).map(style => {
+			return typeof style === "string" ? style : style.content;
+		}).join(" ");
+	}
+
+	return typeof styles === "string" ? styles : styles.content;
+};
+
+const flatten = arr => {
+	return arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val), []);
+};
+
+export default getStylesString;

package/dist/theming/getThemeDesignerTheme.js

@@ -0,0 +1,87 @@
+const warnings = new Set();
+
+const getThemeMetadata = () => {
+	// Check if the class was already applied, most commonly to the link/style tag with the CSS Variables
+	let el = document.querySelector(".sapThemeMetaData-Base-baseLib") || document.querySelector(".sapThemeMetaData-UI5-sap-ui-core");
+	if (el) {
+		return getComputedStyle(el).backgroundImage;
+	}
+
+	el = document.createElement("span");
+	el.style.display = "none";
+
+	// Try with sapThemeMetaData-Base-baseLib first
+	el.classList.add("sapThemeMetaData-Base-baseLib");
+	document.body.appendChild(el);
+	let metadata = getComputedStyle(el).backgroundImage;
+
+	// Try with sapThemeMetaData-UI5-sap-ui-core only if the previous selector was not found
+	if (metadata === "none") {
+		el.classList.add("sapThemeMetaData-UI5-sap-ui-core");
+		metadata = getComputedStyle(el).backgroundImage;
+	}
+
+	document.body.removeChild(el);
+
+	return metadata;
+};
+
+const parseThemeMetadata = metadataString => {
+	const params = /\(["']?data:text\/plain;utf-8,(.*?)['"]?\)$/i.exec(metadataString);
+	if (params && params.length >= 2) {
+		let paramsString = params[1];
+		paramsString = paramsString.replace(/\\"/g, `"`);
+		if (paramsString.charAt(0) !== "{" && paramsString.charAt(paramsString.length - 1) !== "}") {
+			try {
+				paramsString = decodeURIComponent(paramsString);
+			} catch (ex) {
+				if (!warnings.has("decode")) {
+					console.warn("Malformed theme metadata string, unable to decodeURIComponent"); // eslint-disable-line
+					warnings.add("decode");
+				}
+				return;
+			}
+		}
+		try {
+			return JSON.parse(paramsString);
+		} catch (ex) {
+			if (!warnings.has("parse")) {
+				console.warn("Malformed theme metadata string, unable to parse JSON"); // eslint-disable-line
+				warnings.add("parse");
+			}
+		}
+	}
+};
+
+const processThemeMetadata = metadata => {
+	let themeName;
+	let baseThemeName;
+
+	try {
+		themeName = metadata.Path.match(/\.([^.]+)\.css_variables$/)[1];
+		baseThemeName = metadata.Extends[0];
+	} catch (ex) {
+		if (!warnings.has("object")) {
+			console.warn("Malformed theme metadata Object", metadata); // eslint-disable-line
+			warnings.add("object");
+		}
+		return;
+	}
+
+	return {
+		themeName,
+		baseThemeName,
+	};
+};
+
+const getThemeDesignerTheme = () => {
+	const metadataString = getThemeMetadata();
+	if (!metadataString || metadataString === "none") {
+		return;
+	}
+
+	const metadata = parseThemeMetadata(metadataString);
+	return processThemeMetadata(metadata);
+};
+
+export default getThemeDesignerTheme;

package/dist/theming/preloadLinks.js

@@ -0,0 +1,23 @@
+import getEffectiveLinksHrefs from "./getEffectiveLinksHrefs.js";
+import createLinkInHead from "../util/createLinkInHead.js";
+import { shouldUseLinks, shouldPreloadLinks } from "../CSP.js";
+
+const preloaded = new Set();
+
+const preloadLinks = ElementClass => {
+	if (!shouldUseLinks() || !shouldPreloadLinks()) {
+		return;
+	}
+
+	const linksHrefs = getEffectiveLinksHrefs(ElementClass, false) || [];
+	const staticAreaLinksHrefs = getEffectiveLinksHrefs(ElementClass, true) || [];
+
+	[...linksHrefs, ...staticAreaLinksHrefs].forEach(href => {
+		if (!preloaded.has(href)) {
+			createLinkInHead(href, { rel: "preload", as: "style" });
+			preloaded.add(href);
+		}
+	});
+};
+
+export default preloadLinks;

package/dist/thirdparty/_merge.js

@@ -0,0 +1,32 @@
+import isPlainObject from './isPlainObject.js';
+var oToken = Object.create(null);
+var fnMerge = function () {
+    var src, copyIsArray, copy, name, options, clone, target = arguments[2] || {}, i = 3, length = arguments.length, deep = arguments[0] || false, skipToken = arguments[1] ? undefined : oToken;
+    if (typeof target !== 'object' && typeof target !== 'function') {
+        target = {};
+    }
+    for (; i < length; i++) {
+        if ((options = arguments[i]) != null) {
+            for (name in options) {
+                src = target[name];
+                copy = options[name];
+                if (name === '__proto__' || target === copy) {
+                    continue;
+                }
+                if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+                    if (copyIsArray) {
+                        copyIsArray = false;
+                        clone = src && Array.isArray(src) ? src : [];
+                    } else {
+                        clone = src && isPlainObject(src) ? src : {};
+                    }
+                    target[name] = fnMerge(deep, arguments[1], clone, copy);
+                } else if (copy !== skipToken) {
+                    target[name] = copy;
+                }
+            }
+        }
+    }
+    return target;
+};
+export default fnMerge;