ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/shared-chunks/chunk-3SQBS3Y5-Cj4eryg1.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  c: () => decorateClass,
+  f: () => decorateFieldV1,
+  g: () => decorateFieldV2,
+  i: () => initializeDeferredDecorator,
+  m: () => decorateMethodV1,
+  n: () => decorateMethodV2,
+  p: () => decoratePOJO
+});
+var deferred = /* @__PURE__ */new WeakMap();
+function deferDecorator(proto, prop, desc) {
+  let map = deferred.get(proto);
+  if (!map) {
+    map = /* @__PURE__ */new Map();
+    deferred.set(proto, map);
+  }
+  map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = deferred.get(cursor)?.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+function decorateFieldV1(target, prop, decorators, initializer) {
+  return decorateFieldV2(target.prototype, prop, decorators, initializer);
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  };
+  if (initializer) {
+    desc.initializer = initializer;
+  }
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(prototype, prop, desc);
+  } else {
+    deferDecorator(prototype, prop, desc);
+  }
+}
+function decorateMethodV1({
+  prototype
+}, prop, decorators) {
+  return decorateMethodV2(prototype, prop, decorators);
+}
+function decorateMethodV2(prototype, prop, decorators) {
+  const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
+  let desc = {
+    ...origDesc
+  };
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+    desc.initializer = void 0;
+  }
+  Object.defineProperty(prototype, prop, desc);
+}
+function initializeDeferredDecorator(target, prop) {
+  let desc = findDeferredDecorator(target.constructor, prop);
+  if (desc) {
+    Object.defineProperty(target, prop, {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      writable: desc.writable,
+      value: desc.initializer ? desc.initializer.call(target) : void 0
+    });
+  }
+}
+function decorateClass(target, decorators) {
+  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
+}
+function decoratePOJO(pojo, decorated) {
+  for (let [type, prop, decorators] of decorated) {
+    if (type === "field") {
+      decoratePojoField(pojo, prop, decorators);
+    } else {
+      decorateMethodV2(pojo, prop, decorators);
+    }
+  }
+  return pojo;
+}
+function decoratePojoField(pojo, prop, decorators) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
+  };
+  for (let decorator of decorators) {
+    desc = decorator(pojo, prop, desc) || desc;
+  }
+  if (desc.initializer) {
+    desc.value = desc.initializer.call(pojo);
+    delete desc.initializer;
+  }
+  Object.defineProperty(pojo, prop, desc);
+}
+
+export { decorateMethodV2 as a, decorateFieldV2 as d, initializeDeferredDecorator as i };

package/dist/prod/packages/shared-chunks/collections-GpG8lT2g.js

@@ -0,0 +1,75 @@
+function unwrap(val) {
+  return val;
+}
+function expect(val, message) {
+  return val;
+}
+function exhausted(value) {
+}
+
+function isPresentArray(list) {
+  return list ? list.length > 0 : false;
+}
+function asPresentArray(list, message = `unexpected empty list`) {
+  return list;
+}
+function getLast(list) {
+  return list.length === 0 ? undefined : list[list.length - 1];
+}
+function getFirst(list) {
+  return list.length === 0 ? undefined : list[0];
+}
+function mapPresentArray(list, mapper) {
+  if (list === null) {
+    return null;
+  }
+  let out = [];
+  for (let item of list) {
+    out.push(mapper(item));
+  }
+  return out;
+}
+
+function dict() {
+  return Object.create(null);
+}
+function isDict(u) {
+  return u !== null && u !== undefined;
+}
+function isIndexable(u) {
+  return typeof u === 'function' || typeof u === 'object' && u !== null;
+}
+class StackImpl {
+  stack;
+  current = null;
+  constructor(values = []) {
+    this.stack = values;
+  }
+  get size() {
+    return this.stack.length;
+  }
+  push(item) {
+    this.current = item;
+    this.stack.push(item);
+  }
+  pop() {
+    let item = this.stack.pop();
+    this.current = getLast(this.stack) ?? null;
+    return item === undefined ? null : item;
+  }
+  nth(from) {
+    let len = this.stack.length;
+    return len < from ? null : unwrap(this.stack[len - from]);
+  }
+  isEmpty() {
+    return this.stack.length === 0;
+  }
+  snapshot() {
+    return [...this.stack];
+  }
+  toArray() {
+    return this.stack;
+  }
+}
+
+export { StackImpl as S, isPresentArray as a, getLast as b, isIndexable as c, dict as d, expect as e, asPresentArray as f, getFirst as g, exhausted as h, isDict as i, mapPresentArray as m, unwrap as u };