@shopware-ag/meteor-component-library
Version:
The meteor component library is a Vue component library developed by Shopware. It is based on the [Meteor Design System](https://shopware.design/).
1,476 lines (1,475 loc) • 47.8 kB
JavaScript
import { i as isObjectLike, b as baseGetTag, a as isArray, M as MapCache, S as Symbol$1, c as isLength, d as isIndex, e as isArguments, C as Criteria, f as cloneDeep, h as baseClone, j as isObject$1, k as assignValue } from "./useRepository-8f4e50b0.mjs";
var objectProto = Object.prototype;
var hasOwnProperty$1 = objectProto.hasOwnProperty;
function baseHas(object, key) {
return object != null && hasOwnProperty$1.call(object, key);
}
var symbolTag = "[object Symbol]";
function isSymbol(value) {
return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
}
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
function isKey(value, object) {
if (isArray(value)) {
return false;
}
var type = typeof value;
if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
return true;
}
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
}
var FUNC_ERROR_TEXT = "Expected a function";
function memoize(func, resolver) {
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
throw new TypeError(FUNC_ERROR_TEXT);
}
var memoized = function() {
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
if (cache.has(key)) {
return cache.get(key);
}
var result = func.apply(this, args);
memoized.cache = cache.set(key, result) || cache;
return result;
};
memoized.cache = new (memoize.Cache || MapCache)();
return memoized;
}
memoize.Cache = MapCache;
var MAX_MEMOIZE_SIZE = 500;
function memoizeCapped(func) {
var result = memoize(func, function(key) {
if (cache.size === MAX_MEMOIZE_SIZE) {
cache.clear();
}
return key;
});
var cache = result.cache;
return result;
}
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
var reEscapeChar = /\\(\\)?/g;
var stringToPath = memoizeCapped(function(string) {
var result = [];
if (string.charCodeAt(0) === 46) {
result.push("");
}
string.replace(rePropName, function(match, number, quote, subString) {
result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
});
return result;
});
const stringToPath$1 = stringToPath;
function arrayMap(array, iteratee) {
var index = -1, length = array == null ? 0 : array.length, result = Array(length);
while (++index < length) {
result[index] = iteratee(array[index], index, array);
}
return result;
}
var INFINITY$1 = 1 / 0;
var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
function baseToString(value) {
if (typeof value == "string") {
return value;
}
if (isArray(value)) {
return arrayMap(value, baseToString) + "";
}
if (isSymbol(value)) {
return symbolToString ? symbolToString.call(value) : "";
}
var result = value + "";
return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
}
function toString(value) {
return value == null ? "" : baseToString(value);
}
function castPath(value, object) {
if (isArray(value)) {
return value;
}
return isKey(value, object) ? [value] : stringToPath$1(toString(value));
}
var INFINITY = 1 / 0;
function toKey(value) {
if (typeof value == "string" || isSymbol(value)) {
return value;
}
var result = value + "";
return result == "0" && 1 / value == -INFINITY ? "-0" : result;
}
function hasPath(object, path, hasFunc) {
path = castPath(path, object);
var index = -1, length = path.length, result = false;
while (++index < length) {
var key = toKey(path[index]);
if (!(result = object != null && hasFunc(object, key))) {
break;
}
object = object[key];
}
if (result || ++index != length) {
return result;
}
length = object == null ? 0 : object.length;
return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
}
function has(object, path) {
return object != null && hasPath(object, path, baseHas);
}
function generateUniqueId() {
return String(Date.now().toString(36) + Math.random().toString(36).substr(2));
}
function isObject(value) {
return value !== null && typeof value === "object";
}
function getWindowSrc() {
const location = window.location;
const urlObject = new URL(location.pathname, location.origin);
return urlObject.toString();
}
function hasType(type, obj) {
return isObject(obj) && obj.__type__ && obj.__type__ === type;
}
function hasOwnProperty(obj, path) {
return has(obj, path);
}
function traverseObject(traversableObject, processor, previousKey = "root") {
for (let index in traversableObject) {
const currentEntry = traversableObject[index];
processor.apply(this, [traversableObject, index, currentEntry, previousKey]);
if (isObject(currentEntry)) {
let pk = previousKey + "." + index;
traverseObject(currentEntry, processor, pk);
}
}
}
function isPrimitive(value) {
return value !== Object(value) || value === null || value === void 0;
}
function removeRoot(path) {
if (typeof path !== "string") {
return path;
}
return path.replace(/^root\./, "");
}
function findExtensionByBaseUrl(baseUrl) {
if (typeof baseUrl !== "string") {
return void 0;
}
if (baseUrl === "") {
return void 0;
}
const comparedBaseUrl = new URL(baseUrl);
if (comparedBaseUrl.origin === window.location.origin) {
return {
baseUrl: comparedBaseUrl.hostname,
permissions: {
additional: ["*"],
create: ["*"],
read: ["*"],
update: ["*"],
delete: ["*"]
}
};
}
return Object.values(window._swsdk.adminExtensions).find((ext) => {
const extensionBaseUrl = new URL(ext.baseUrl);
return extensionBaseUrl.hostname === comparedBaseUrl.hostname;
});
}
class MissingPrivilegesError extends Error {
constructor(messageType, missingPrivileges) {
super(`Your app is missing the privileges ${missingPrivileges.join(", ")} for action "${messageType}".`);
Object.defineProperty(this, "missingPrivileges", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "messageType", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.missingPrivileges = missingPrivileges;
this.messageType = messageType;
Object.setPrototypeOf(this, MissingPrivilegesError.prototype);
}
toJSON() {
return {
__type__: "__MissingPrivilegesError__",
__messageType__: this.messageType,
__data__: this.missingPrivileges
};
}
}
var __awaiter$1 = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
const FunctionSerializerFactory = ({ send: send2, handle: handle2 }) => {
const methodRegistry = {};
let isMethodHandlerStarted = false;
function startMethodHandler() {
if (isMethodHandlerStarted)
return;
isMethodHandlerStarted = true;
handle2("__function__", ({ args, id }) => __awaiter$1(this, void 0, void 0, function* () {
return yield Promise.resolve(methodRegistry[id](...args));
}));
}
return {
name: "function",
serialize: ({ value }) => {
if (typeof value === "function") {
const id = generateUniqueId();
methodRegistry[id] = value;
startMethodHandler();
return {
__type__: "__function__",
id,
origin: window.origin
};
}
},
deserialize: ({ value, event }) => {
var _a;
const targetWindow = (_a = event === null || event === void 0 ? void 0 : event.source) !== null && _a !== void 0 ? _a : window;
if (isObject(value) && value["__type__"] && value["__type__"] === "__function__" && typeof value["id"] === "string") {
const id = value["id"];
const origin = value["origin"];
return (...args) => {
return send2("__function__", {
args,
id
}, targetWindow, origin);
};
}
}
};
};
const CriteriaSerializer = () => ({
name: "criteria",
serialize: ({ value, customizerMethod, seen, path }) => {
if (value instanceof Criteria) {
return {
__type__: "__Criteria__",
data: customizerMethod(value.getCriteriaData(), seen, path)
};
}
},
deserialize: ({ value, customizerMethod }) => {
if (hasType("__Criteria__", value) && typeof value["data"] === "object") {
const serializedData = value.data;
const deserializedCriteria = new Criteria();
deserializedCriteria.setPage(serializedData.page);
deserializedCriteria.setLimit(serializedData.limit);
deserializedCriteria.setTerm(serializedData.term);
if (serializedData.title !== null) {
deserializedCriteria.setTitle(serializedData.title);
}
serializedData.filters.forEach((filter) => {
deserializedCriteria.addFilter(filter);
});
deserializedCriteria.setIds(serializedData.ids);
serializedData.queries.forEach(({ query, score }) => {
deserializedCriteria.addQuery(query, score);
});
serializedData.associations.forEach((association) => {
deserializedCriteria.associations.push(customizerMethod(association));
});
serializedData.postFilter.forEach((filter) => {
deserializedCriteria.addPostFilter(filter);
});
serializedData.sortings.forEach((sorting) => {
deserializedCriteria.addSorting(sorting);
});
serializedData.aggregations.forEach((aggregation) => {
deserializedCriteria.addAggregation(aggregation);
});
serializedData.grouping.forEach((group) => {
deserializedCriteria.addGrouping(group);
});
serializedData.fields.forEach((field) => {
deserializedCriteria.addFields(field);
});
serializedData.groupFields.forEach((groupField) => {
deserializedCriteria.addGroupField(groupField);
});
if (serializedData.includes) {
deserializedCriteria.addIncludes(serializedData.includes);
}
deserializedCriteria.setTotalCountMode(serializedData.totalCountMode);
return deserializedCriteria;
}
}
});
let setterMethod = (draft, property, value) => {
draft[property] = value;
};
class EntityClass {
constructor(id, entityName, data, options = {}) {
var _a, _b;
Object.defineProperty(this, "id", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_origin", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_entityName", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_draft", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_isDirty", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_isNew", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.id = id;
this._origin = options.originData ? cloneDeep(options.originData) : cloneDeep(data);
this._entityName = entityName;
this._draft = data;
this._isDirty = (_a = options.isDirty) !== null && _a !== void 0 ? _a : false;
this._isNew = (_b = options.isNew) !== null && _b !== void 0 ? _b : false;
const that = this;
return new Proxy(this._draft, {
get(_, property) {
if (property in that._draft) {
return that._draft[property];
}
return that[property];
},
set(_, property, value) {
setterMethod(that._draft, property, value);
that._isDirty = true;
return true;
}
});
}
/**
* Identifier method for the entity class. Needed when some reactive data layer (Vue) converts the EntityClass to a
* plain object. With this identifier method we can (de)serialie it back to the correct entity class.
*/
__identifier__() {
return "Entity";
}
/**
* Marks the entity as new. New entities will be provided as create request to the server
*/
markAsNew() {
this._isNew = true;
}
/**
* Allows to check if the entity is a new entity and should be provided as create request to the server
*/
isNew() {
return this._isNew;
}
/**
* Allows to check if the entity changed
*/
getIsDirty() {
return this._isDirty;
}
/**
* Allows access the origin entity value. The origin value contains the server values
*/
getOrigin() {
return this._origin;
}
/**
* Allows to access the draft value. The draft value contains all local changes of the entity
*/
getDraft() {
return this._draft;
}
/**
* Allows to access the entity name. The entity name is used as unique identifier `product`, `media`, ...
*/
getEntityName() {
return this._entityName;
}
}
const Entity = function Entity2(id, entityName, data, options) {
return new EntityClass(id, entityName, data, options);
};
const EntitySerializerFactory = () => ({
name: "entity",
serialize: ({ value, customizerMethod, seen, path }) => {
if (!isObject(value) || typeof value.__identifier__ !== "function" || value.__identifier__() !== "Entity") {
return;
}
return {
__type__: "__Entity__",
__id__: value.id,
__entityName__: value._entityName,
__isDirty__: value._isDirty,
__isNew__: value._isNew,
__origin__: customizerMethod(value._origin, seen, path),
__draft__: customizerMethod(value._draft, seen, path)
};
},
deserialize: ({ value, customizerMethod }) => {
if (hasType("__Entity__", value) && typeof value.__origin__ === "object") {
return new Entity(value.__id__, value.__entityName__, customizerMethod(value.__draft__), {
originData: customizerMethod(value.__origin__),
isDirty: value.__isDirty__,
isNew: value.__isNew__
});
}
}
});
class EntityCollection extends Array {
constructor(source, entityName, context, criteria = null, entities = [], total = null, aggregations = null) {
super();
Object.defineProperty(this, "entity", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "source", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "context", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "criteria", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "aggregations", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "total", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "first", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "last", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "remove", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "has", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "get", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "getAt", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "getIds", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "add", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "addAt", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "moveItem", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "__identifier__", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.entity = entityName;
this.source = source;
this.context = context;
this.criteria = criteria;
this.aggregations = aggregations;
this.total = total;
this.push(...entities);
this.__identifier__ = () => {
return "EntityCollection";
};
this.first = function firstEntityOfCollection() {
if (this.length <= 0) {
return null;
}
return this[0];
};
this.last = function lastEntityOfCollection() {
if (this.length <= 0) {
return null;
}
return this[this.length - 1];
};
this.remove = function removeEntityFromCollection(id) {
const itemIndex = this.findIndex((i) => i.id === id);
if (itemIndex < 0) {
return false;
}
this.splice(itemIndex, 1);
return true;
};
this.has = function hasEntityInCollection(id) {
return this.some((i) => i.id === id);
};
this.get = function getEntityByIdOfCollection(id) {
const item = this.find((i) => i.id === id);
if (typeof item !== "undefined") {
return item;
}
return null;
};
this.getAt = function getEntityAtIndexOfCollection(index) {
const item = this[index];
if (typeof item !== "undefined") {
return item;
}
return null;
};
this.getIds = function getEntityIdsOfCollection() {
return this.map((i) => i.id);
};
this.add = function addEntityToCollection(e) {
this.push(e);
};
this.addAt = function addEntityAtIndexOfCollection(e, insertIndex) {
if (typeof insertIndex === "undefined") {
this.add(e);
return;
}
this.splice(insertIndex, 0, e);
};
this.moveItem = function moveEntityToNewIndexInCollection(oldIndex, newIndex = null) {
if (newIndex === null) {
newIndex = this.length;
}
if (oldIndex < 0 || oldIndex >= this.length) {
return null;
}
if (newIndex === oldIndex) {
return this.getAt(oldIndex);
}
const movedItem = this.find((_, index) => index === oldIndex);
if (typeof movedItem === "undefined") {
return null;
}
const remainingItems = this.filter((_, index) => index !== oldIndex);
const orderedItems = [
...remainingItems.slice(0, newIndex),
movedItem,
...remainingItems.slice(newIndex)
];
this.splice(0, this.length, ...orderedItems);
return movedItem;
};
this.filter = function filterEntityCollection(callback, scope) {
const filtered = Object.getPrototypeOf(this).filter.call(this, callback, scope);
return new EntityCollection(this.source, this.entity, this.context, this.criteria, filtered, this.total, this.aggregations);
};
}
/**
* Returns a new collection from given one with
*/
static fromCollection(collection) {
return new EntityCollection(collection.source, collection.entity, collection.context, collection.criteria === null ? collection.criteria : Criteria.fromCriteria(collection.criteria), collection, collection.total, collection.aggregations);
}
}
const EntityCollectionSerializerFactory = () => ({
name: "entity-collection",
serialize: ({ value, customizerMethod, seen, path }) => {
if (value instanceof EntityCollection || (value === null || value === void 0 ? void 0 : value.__identifier__) && value.__identifier__() === "EntityCollection") {
return customizerMethod({
__type__: "__EntityCollection__",
__source__: value.source,
__entityName__: value.entity,
__context__: value.context,
__criteria__: value.criteria,
__entities__: Array.from(value),
__total__: value.total,
__aggregations__: value.aggregations
}, seen, path);
}
},
deserialize: ({ value, customizerMethod }) => {
if (hasType("__EntityCollection__", value)) {
return new EntityCollection(value.__source__, value.__entityName__, value.__context__, customizerMethod(value.__criteria__), customizerMethod(value.__entities__), value.__total__, value.__aggregations__);
}
}
});
class HandleError extends Error {
constructor(msg, code) {
super(msg);
Object.defineProperty(this, "code", {
enumerable: true,
configurable: true,
writable: true,
value: 500
});
if (!code) {
return;
}
this.code = code;
}
toJSON() {
return {
__type__: "__HandleError__",
__code__: this.code,
__message__: this.message
};
}
}
const HandleErrorSerializerFactory = () => ({
name: "handle-error",
// serialize is empty because the error contains a toJSON function
serialize: () => {
},
deserialize: ({ value }) => {
if (hasType("__HandleError__", value)) {
return new HandleError(value.__message__, value.__code__);
}
}
});
var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
function cloneDeepWith(value, customizer) {
customizer = typeof customizer == "function" ? customizer : void 0;
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
}
function baseGet(object, path) {
path = castPath(path, object);
var index = 0, length = path.length;
while (object != null && index < length) {
object = object[toKey(path[index++])];
}
return index && index == length ? object : void 0;
}
function get(object, path, defaultValue) {
var result = object == null ? void 0 : baseGet(object, path);
return result === void 0 ? defaultValue : result;
}
function baseSet(object, path, value, customizer) {
if (!isObject$1(object)) {
return object;
}
path = castPath(path, object);
var index = -1, length = path.length, lastIndex = length - 1, nested = object;
while (nested != null && ++index < length) {
var key = toKey(path[index]), newValue = value;
if (key === "__proto__" || key === "constructor" || key === "prototype") {
return object;
}
if (index != lastIndex) {
var objValue = nested[key];
newValue = customizer ? customizer(objValue, key, nested) : void 0;
if (newValue === void 0) {
newValue = isObject$1(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
}
}
assignValue(nested, key, newValue);
nested = nested[key];
}
return object;
}
function set(object, path, value) {
return object == null ? object : baseSet(object, path, value);
}
const MissingPrivilegesErrorSerializer = () => ({
name: "handle-error",
// serialize is empty because the error contains a toJSON function
serialize: () => {
},
deserialize: ({ value }) => {
if (hasType("__MissingPrivilegesError__", value)) {
return new MissingPrivilegesError(value.__messageType__, value.__data__);
}
}
});
const serializerFactories = [
CriteriaSerializer,
EntityCollectionSerializerFactory,
EntitySerializerFactory,
FunctionSerializerFactory,
HandleErrorSerializerFactory,
MissingPrivilegesErrorSerializer
];
function mainSerializerFactory(dependencies2) {
const serializers = serializerFactories.map((serializerFactory) => serializerFactory(dependencies2));
function getSerializers() {
return serializers;
}
function getSerializerByName(name2) {
var _a;
return (_a = serializers.find((serializer) => serializer.name === name2)) !== null && _a !== void 0 ? _a : null;
}
function serialize2(messageData, seen = /* @__PURE__ */ new Map(), path = "root") {
return cloneDeepWith(messageData, (value, key, object, stack) => {
let p = path + "." + key;
if (isPrimitive(value)) {
return value;
}
if (seen.has(value)) {
return {
__$CR__: seen.get(value)
};
}
seen.set(value, p);
for (const serializer of serializers) {
const result = serializer.serialize({
value,
key,
object,
stack,
customizerMethod: serialize2,
seen,
path: p
});
if (result) {
return result;
}
}
});
}
function deserialize2(messageData, event) {
const desirialized = _deserialize(messageData, event);
traverseObject(desirialized, (_, key, value, previousKey) => {
if (key !== "__$CR__") {
return;
}
const path = removeRoot(value);
const reference = removeRoot(previousKey);
set(desirialized, reference, get(desirialized, path));
});
return desirialized;
}
function _deserialize(messageData, event) {
return cloneDeepWith(messageData, (value, key, object, stack) => {
for (const serializer of serializers) {
const result = serializer.deserialize({
value,
key,
object,
stack,
event,
customizerMethod: _deserialize
});
if (result) {
return result;
}
}
});
}
return {
getSerializers,
getSerializerByName,
serialize: serialize2,
deserialize: deserialize2
};
}
function createError(type, e) {
if (typeof e === "string") {
return new HandleError(e);
}
if (!(e instanceof Error)) {
return new HandleError("An unknown error occurred.");
}
if (hasOwnProperty(e, "response.data.errors.0.code") && e.response.data.errors.length) {
const missingPrivilegeErrors = e.response.data.errors.filter((error) => error.code === "FRAMEWORK__MISSING_PRIVILEGE_ERROR");
const missingPrivileges = [];
missingPrivilegeErrors.forEach((mpe) => {
const data = JSON.parse(mpe.detail);
missingPrivileges.push(...data.missingPrivileges);
});
if (missingPrivileges.length) {
return new MissingPrivilegesError(type, missingPrivileges);
}
return new HandleError(e.response.data.errors[0].code, e.response.data.errors[0].status);
}
return new HandleError(e.message);
}
function validate({ serializedData, origin, type, privilegesToCheck = [] }) {
if (origin === void 0) {
return null;
}
const extension = findExtensionByBaseUrl(origin);
if (!extension) {
console.warn(`No extension found for origin "${origin}"`);
return null;
}
const privilegeErrors = [];
traverseObject(serializedData, (parentEntry, key, value) => {
if (key === "__type__" && ["__EntityCollection__", "__Entity__"].includes(value)) {
const entityName = parentEntry.__entityName__;
if (!entityName) {
return;
}
[...privilegesToCheck].sort().forEach((privilege) => {
const permissionsForPrivilege = extension.permissions[privilege];
if ((!permissionsForPrivilege || !permissionsForPrivilege.includes(entityName)) && !privilegeErrors.includes(`${privilege}:${entityName}`) && !(permissionsForPrivilege === null || permissionsForPrivilege === void 0 ? void 0 : permissionsForPrivilege.includes("*"))) {
privilegeErrors.push(`${privilege}:${entityName}`);
}
});
}
});
if (privilegeErrors.length > 0) {
return new MissingPrivilegesError(type, privilegeErrors);
}
return null;
}
function selectData(sourceData, selectors, messageType = "datasetSubscribe", origin = "") {
if (!selectors) {
return sourceData;
}
const result = {};
const extension = findExtensionByBaseUrl(origin !== null && origin !== void 0 ? origin : "");
const permissionErrors = [];
selectors.forEach((selector) => {
selectValue(sourceData, selector, extension, permissionErrors, origin, messageType, result);
});
if (!extension) {
console.warn(`No extension found for origin "${origin}"`);
return result;
}
if (permissionErrors.length) {
return new MissingPrivilegesError(messageType, permissionErrors);
}
return result;
}
function selectValue(data, selector, extension, permissionErrors, origin, messageType, result = {}) {
var _a, _b, _c;
const parts = selector.split(".");
let tmpResult = result;
let tmpData = data;
for (let i = 0; i < parts.length; i++) {
const specificArrayMatcher = /\[\d*\]/;
const currentPart = parts[i];
const nextPart = parts[i + 1];
if (nextPart && (nextPart === "*" || nextPart.match(specificArrayMatcher))) {
if (!parts[i + 2]) {
checkPermission(tmpData, extension, permissionErrors);
checkPermission(tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart], extension, permissionErrors);
tmpResult[currentPart] = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
break;
}
tmpResult[currentPart] = (_a = tmpResult[currentPart]) !== null && _a !== void 0 ? _a : [];
tmpData = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
tmpResult = tmpResult[currentPart];
continue;
}
if (Array.isArray(tmpData) && nextPart) {
const selectorAfterCurrent = parts.slice(i + 1).join(".");
if (currentPart === "*") {
for (let j = 0; j < tmpData.length; j++) {
selectValue(
tmpData[j],
selectorAfterCurrent,
extension,
permissionErrors,
origin,
messageType,
// Result is either the root array or the existing array entry
(_b = tmpResult[j]) !== null && _b !== void 0 ? _b : tmpResult
);
}
break;
}
if (currentPart.match(specificArrayMatcher)) {
const index = parseArrayIndex(currentPart);
selectValue(
tmpData[index],
selectorAfterCurrent,
extension,
permissionErrors,
origin,
messageType,
// Result is either the root array or the existing array entry
(_c = tmpResult[index]) !== null && _c !== void 0 ? _c : tmpResult
);
break;
}
}
if (i === parts.length - 1) {
checkPermission(tmpData, extension, permissionErrors);
checkPermission(tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart], extension, permissionErrors);
if (Array.isArray(tmpResult)) {
tmpResult.push({ [currentPart]: tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart] });
break;
}
tmpResult[currentPart] = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
break;
}
tmpResult[currentPart] = {};
tmpData = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
tmpResult = tmpResult[currentPart];
}
return result;
}
function checkPermission(data, extension, permissionErrors) {
if (!data) {
return;
}
const permissionsToCheck = ["read"];
let entityName = "";
if (data.__identifier__ && data.__identifier__() === "Entity") {
entityName = data.getEntityName();
}
if (data.__identifier__ && data.__identifier__() === "EntityCollection") {
entityName = data.entity;
}
if (!entityName) {
return;
}
permissionsToCheck.forEach((privilege) => {
var _a;
const permissionsForPrivilege = (_a = extension === null || extension === void 0 ? void 0 : extension.permissions) === null || _a === void 0 ? void 0 : _a[privilege];
if ((!permissionsForPrivilege || !permissionsForPrivilege.includes(entityName)) && !permissionErrors.includes(`${privilege}:${entityName}`) && !(permissionsForPrivilege === null || permissionsForPrivilege === void 0 ? void 0 : permissionsForPrivilege.includes("*"))) {
permissionErrors.push(`${privilege}:${entityName}`);
}
});
}
function parseArrayIndex(index) {
return Number.parseInt(index.replace("[", "").replace("]", ""));
}
const name = "@shopware-ag/meteor-admin-sdk";
const version = "6.5.1";
const description = "The Meteor SDK for the Shopware Administration.";
const keywords = [
"iframe",
"shopware",
"admin",
"bridge",
"app",
"sdk"
];
const repository = {
type: "git",
url: "git+ssh://git@github.com:shopware/meteor.git"
};
const license = "MIT";
const exports = {
"./es/channel": {
"import": "./es/channel.js",
require: "./umd/channel.js"
},
"./es/data": {
"import": "./es/data/index.js",
require: "./umd/data/index.js"
},
"./es/location": {
"import": "./es/location/index.js",
require: "./umd/location/index.js"
},
"./es/_internals/privileges/missing-privileges-error": {
"import": "./es/_internals/privileges/missing-privileges-error.js",
require: "./umd/_internals/privileges/missing-privileges-error.js"
},
"./es/_internals/data/selectData": {
"import": "./es/_internals/data/selectData.js",
require: "./umd/_internals/data/selectData.js"
},
"./es/data/Criteria": {
"import": "./es/data/Criteria.js",
require: "./umd/data/Criteria.js"
},
"./es/_internals/data/Entity": {
"import": "./es/_internals/data/Entity.js",
require: "./umd/_internals/data/Entity.js"
},
"./es/_internals/data/EntityCollection": {
"import": "./es/_internals/data/EntityCollection.js",
require: "./umd/_internals/data/EntityCollection.js"
},
"./es/data/repository": {
"import": "./es/data/repository.js",
require: "./umd/data/repository.js"
},
"./es/data/data-table-filter.helper": {
"import": "./es/data/data-table-filter.helper.js",
require: "./umd/data/data-table-filter.helper.js"
},
"./es/data/composables": {
"import": "./es/data/composables/index.js",
require: "./umd/data/composables/index.js"
},
"./es/data/composables/useSharedState": {
"import": "./es/data/composables/useSharedState.js",
require: "./umd/data/composables/useSharedState.js"
},
"./es/data/composables/useRepository": {
"import": "./es/data/composables/useRepository.js",
require: "./umd/data/composables/useRepository.js"
},
"./es/data/composables/getRepository": {
"import": "./es/data/composables/getRepository.js",
require: "./umd/data/composables/getRepository.js"
},
".": {
"import": "./es/index.js",
require: "./umd/index.js"
}
};
const main = "./umd/index.js";
const module = "./es/index.js";
const types = "./es/index.d.ts";
const files = [
"umd",
"es",
"cdn"
];
const scripts = {
build: "rm -rf es && rm -rf umd && rm -rf cdn && npm run build:umd && npm run build:es && npm run build:cdn",
"build:cdn": "vite build --mode cdn",
"build:es": 'tsc --project tsconfig.json --outDir "./es"',
"build:umd": 'tsc --project tsconfig.json --module umd --outDir "./umd"',
"circular-dependencies": "madge --circular --warning src",
"circular-dependencies:image": "madge --circular --warning --image ./dependency-graph.png src",
dev: 'concurrently "npm run dev:build-watch" "npm run dev:serve -- --port=8181" "npm run dev:serve -- --port=8182"',
"dev:build-watch": "vite build --watch --mode example --emptyOutDir",
"dev:serve": "http-server testpageDist --silent",
"docs:env": '[ -d "../../../developer-portal" ] && ../../../developer-portal/docs-cli.cjs pull || (git clone git@github.com:shopware/developer-portal.git ../../../developer-portal && pnpm i -C ../../../developer-portal)',
"docs:link": "../../../developer-portal/docs-cli.cjs link --src ../../docs/admin-sdk --dst resources/admin-extension-sdk --symlink",
"docs:preview": "../../../developer-portal/docs-cli.cjs preview",
"lint:all": "npm run lint:types && npm run lint:eslint",
"lint:eslint": "eslint ./src --ext .ts",
"lint:types": "tsc --noEmit",
prepublish: "npm run build",
"test:e2e": 'concurrently --handle-input --kill-others --success first "npm run dev" "wait-on http://127.0.0.1:8181 && wait-on http://127.0.0.1:8182 && playwright test"',
"test:e2e:dev": "playwright test --project=chromium --reporter=list",
"test:e2e:dev-debug": "PWDEBUG=1 npm run test:e2e:dev",
"test:e2e:dev-watch": `chokidar "{e2e,src}/**/*.{js,ts}" -c 'clear && npm run test:e2e:dev' --initial`,
"test:unit": "jest --collectCoverage",
"test:unit:watch": "npm run circular-dependencies && jest --watch"
};
const dependencies = {
"jwt-decode": "^4.0.0",
localforage: "^1.10.0",
"lodash-es": "^4.17.21",
semver: "^7.7.1"
};
const devDependencies = {
"@playwright/test": "^1.45.0",
"@types/jest": "^27.4.1",
"@types/lodash-es": "^4.17.12",
"@types/node": "^18.11.17",
"@typescript-eslint/eslint-plugin": "^5.47.0",
"@typescript-eslint/parser": "^8.36.0",
"chokidar-cli": "^3.0.0",
concurrently: "^7.0.0",
eslint: "^8.11.0",
"eslint-plugin-check-file": "^2.7.0",
"eslint-plugin-import": "^2.31.0",
"flush-promises": "^1.0.2",
"http-server": "^14.1.0",
jest: "^27.5.1",
"jest-fail-on-console": "^2.2.3",
madge: "^5.0.1",
"ts-jest": "^27.1.3",
typescript: "^4.9.4",
vite: "^2.8.6",
"vite-plugin-dts": "^0.9.10",
"vite-tsconfig-paths": "^3.4.1",
vue: "^2.7.14",
"wait-on": "^6.0.1"
};
const packageJson = {
name,
version,
description,
keywords,
repository,
license,
exports,
main,
module,
types,
files,
scripts,
dependencies,
devDependencies
};
const sdkVersion = packageJson.version;
var __awaiter = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
const packageVersion = sdkVersion;
const { serialize, deserialize } = mainSerializerFactory({
handle,
send
});
const adminExtensions = {};
const sourceRegistry = /* @__PURE__ */ new Set();
const subscriberRegistry = /* @__PURE__ */ new Set();
function send(type, data, _targetWindow, _origin) {
const callbackId = generateUniqueId();
const sendData = data !== null && data !== void 0 ? data : {};
const messageData = {
_type: type,
_data: sendData,
_callbackId: callbackId
};
let serializedData = serialize(messageData);
if (_origin) {
const validationErrors = validate({
serializedData,
origin: _origin,
privilegesToCheck: ["read"],
type
});
if (validationErrors) {
if ([
"datasetSubscribe",
"datasetUpdate",
"datasetRegistration",
"datasetGet"
].includes(serializedData._type)) {
serializedData = serialize({
_type: serializedData._type,
_callbackId: serializedData._callbackId,
_data: {
// @ts-expect-error - We know with the includes that it has an ID
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
id: serializedData._data.id,
data: validationErrors
}
});
} else {
serializedData = serialize({
_type: serializedData._type,
_callbackId: serializedData._callbackId,
_data: validationErrors
});
}
}
}
const message = JSON.stringify(serializedData);
let isResolved = false;
const timeoutMs = 7e3;
return new Promise((resolve, reject) => {
const callbackHandler = function(event) {
if (typeof event.data !== "string") {
return;
}
if (event.data.indexOf(`"_callbackId":"${callbackId}"`) === -1) {
return;
}
let shopwareResponseData;
try {
shopwareResponseData = JSON.parse(event.data);
} catch (_a) {
return;
}
if (!isMessageResponseData(shopwareResponseData)) {
return;
}
if (!shopwareResponseData.hasOwnProperty("_response")) {
return;
}
const deserializedResponseData = deserialize(shopwareResponseData, event);
window.removeEventListener("message", callbackHandler);
if (!isResolved) {
isResolved = true;
const response = deserializedResponseData._response;
if (response instanceof Error) {
reject(response);
return;
}
resolve(response);
}
};
window.addEventListener("message", callbackHandler);
let corsRestriction = true;
try {
corsRestriction = !window.parent.origin;
} catch (_a) {
}
let targetOrigin = corsRestriction ? document.referrer : window.parent.origin;
if (_origin) {
targetOrigin = _origin;
}
_targetWindow ? _targetWindow.postMessage(message, targetOrigin) : window.parent.postMessage(message, targetOrigin);
setTimeout(() => {
if (isResolved) {
return;
}
reject("Send timeout expired. It could be possible that no handler for the postMessage request exists or that the handler freezed.");
}, timeoutMs);
});
}
function handle(type, method) {
const handleListener = function(event) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
if (typeof event.data !== "string") {
return;
}
if (event.data.indexOf(`"_type":"${type}"`) === -1) {
return;
}
let shopwareMessageData;
try {
shopwareMessageData = JSON.parse(event.data);
} catch (_b) {
return;
}
if (!isMessageData(shopwareMessageData)) {
return;
}
const deserializedMessageData = deserialize(shopwareMessageData, event);
const responseValue = yield Promise.resolve((() => {
const responseValidationTypes = [
"datasetSubscribe",
"datasetGet",
"datasetUpdate",
// Test value
"_collectionTest"
];
if (!responseValidationTypes.includes(type)) {
return method(deserializedMessageData._data, { _event_: event });
}
const validationErrors = validate({
serializedData: shopwareMessageData,
origin: event.origin,
type,
privilegesToCheck: ["create", "delete", "update", "read"]
});
if (validationErrors) {
return validationErrors;
}
return method(deserializedMessageData._data, { _event_: event });
})()).catch((e) => createError(type, e));
const responseMessage = {
_callbackId: deserializedMessageData._callbackId,
_type: deserializedMessageData._type,
_response: responseValue !== null && responseValue !== void 0 ? responseValue : null
};
const serializedResponseMessage = (() => {
let serializedMessage = serialize(responseMessage);
const messageValidationTypes = [
"datasetSubscribe",
"datasetGet",
// Test value
"_collectionTest"
];
if (!messageValidationTypes.includes(type)) {
return serializedMessage;
}
const validationErrors = validate({
serializedData: serializedMessage,
origin: event.origin,
privilegesToCheck: ["read"],
type
});
if (validationErrors) {
serializedMessage._response = validationErrors;
serializedMessage = serialize(serializedMessage);
}
return serializedMessage;
})();
const stringifiedResponseMessage = JSON.stringify(serializedResponseMessage);
if (event.source) {
event.source.postMessage(stringifiedResponseMessage, {
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
targetOrigin: (_a = event.origin) !== null && _a !== void 0 ? _a : "*"
});
} else {
window.postMessage(stringifiedResponseMessage, window.origin);
}
});
};
window.addEventListener("message", handleListener);
return () => window.removeEventListener("message", handleListener);
}
function createSender(messageType, baseMessageOptions) {
return (messageOptions) => {
return send(messageType, Object.assign(Object.assign({}, baseMessageOptions), messageOptions));
};
}
const datasets = /* @__PURE__ */ new Map();
(() => __awaiter(void 0, void 0, void 0, function* () {
handle("__registerWindow__", ({ sdkVersion: sdkVersion2 }, additionalOptions) => {
let source;
let origin;
if (additionalOptions._event_.source) {
source = additionalOptions._event_.source;
origin = additionalOptions._event_.origin;
} else {
source = window;
origin = window.origin;
}
sourceRegistry.add({
source,
origin,
sdkVersion: sdkVersion2
});
});
handle("datasetSubscribeRegistration", (data, { _event_ }) => {
let source;
let origin;
if (_event_.source) {
source = _event_.source;
origin = _event_.origin;
} else {
source = window;
origin = window.origin;
}
subscriberRegistry.add({
id: data.id,
source,
origin,
selectors: data.selectors
});
const dataset = datasets.get(data.id);
if (dataset) {
const selectedData = selectData(dataset, data.selectors, "datasetSubscribe", origin);
if (selectedData instanceof MissingPrivilegesError) {
console.error(selectedData);
return;
}
void send("datasetSubscribe", {
id: data.id,
data: selectedData,
selectors: data.selectors
}, source, origin);
}
});
yield send("__registerWindow__", {
sdkVersion: packageVersion
});
}))().catch((e) => console.error(e));
window._swsdk = {
sourceRegistry,
subscriberRegistry,
datasets,
adminExtensions
};
function isMessageData(eventData) {
const shopwareMessageData = eventData;
return !!shopwareMessageData._type && !!shopwareMessageData._data && !!shopwareMessageData._callbackId;
}
function isMessageResponseData(eventData) {
const shopwareMessageData = eventData;
return !!shopwareMessageData._type && !!shopwareMessageData.hasOwnProperty("_response") && !!shopwareMessageData._callbackId;
}
export {
createSender as c,
getWindowSrc as g,
handle as h,
mainSerializerFactory as m,
send as s
};
//# sourceMappingURL=channel-e8be2d79.mjs.map