@lifeart/gxt/dist/gxt.glimmer-compat.es.js

<img align="right" width="95" height="95" alt="Philosopher’s stone, logo of PostCSS" src="./public/logo.png">

import { f as formula, ao as evaluateOpcode, ap as opcodeFor, c as cell, aq as isFn, ar as lazyRawCellFor, as as cellsMap, at as getTracker, au as isRendering, av as setIsRendering, a as cellFor } from './reactive-CVZF9xBs.js';
export { aw as destroyable } from './reactive-CVZF9xBs.js';

function createCache(fn) {
  const tag = formula(fn);
  let initValue = null;
  let relatedCells = /* @__PURE__ */ new Set();
  let calcVersion = 0;
  evaluateOpcode(tag, (value) => {
    initValue = value;
  });
  tag.relatedCells?.forEach((cell) => {
    relatedCells.add(cell);
  });
  let consumeCells = () => Array.from(relatedCells).map((cell) => cell.value);
  const updateTag = formula(consumeCells);
  let updatingOpcodeDestructor = opcodeFor(updateTag, () => {
    calcVersion++;
  });
  let lastCalcVersion = calcVersion;
  return {
    tag,
    get value() {
      if (calcVersion !== lastCalcVersion) {
        lastCalcVersion = calcVersion;
        initValue = fn();
      }
      return initValue;
    },
    destroy() {
      tag.destroy();
      updateTag.destroy();
      updatingOpcodeDestructor();
    }
  };
}
function getValue$1(cache) {
  return cache.value;
}
function isConst(cache) {
  return cache.tag.isConst;
}

const cachingPrimitives = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  createCache,
  getValue: getValue$1,
  isConst
}, Symbol.toStringTag, { value: 'Module' }));

function createStorage(initialValue, isEqual) {
  return {
    cell: cell(initialValue, "storage-primitive"),
    update(value) {
      if (isFn(isEqual) && isEqual(this.cell.value, value)) {
        return;
      }
      this.cell.update(value);
    }
  };
}
function getValue(storage) {
  return storage.cell.value;
}
function setValue(storage, value) {
  storage.update(value);
}

const storagePrimitives = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  createStorage,
  getValue,
  setValue
}, Symbol.toStringTag, { value: 'Module' }));

const tagFor = lazyRawCellFor;
function dirtyTagFor(obj, key) {
  const cell2 = lazyRawCellFor(obj, key);
  cell2.update(cell2.value);
}
function tagMetaFor(obj) {
  return cellsMap.get(obj);
}
function isTracking() {
  return getTracker() !== null;
}
function consumeTag(tag) {
  const TRACKER = getTracker();
  if (TRACKER !== null) {
    TRACKER.add(tag);
  }
}
function trackedData(key, initializer) {
  function getter(self) {
    const tag = lazyRawCellFor(self, key, initializer);
    return tag.value;
  }
  function setter(self, value) {
    const tag = lazyRawCellFor(self, key, initializer);
    tag.update(value);
  }
  return {
    getter,
    setter
  };
}
let renderingStateBeforeBegin = isRendering();
function beginTrackFrame() {
  renderingStateBeforeBegin = isRendering();
  if (!isRendering()) {
    setIsRendering(true);
  }
}
function endTrackFrame() {
  if (isRendering() !== renderingStateBeforeBegin) {
    setIsRendering(renderingStateBeforeBegin);
  }
}
function track(cb) {
  beginTrackFrame();
  try {
    return cb();
  } finally {
    endTrackFrame();
  }
}
function untrack(cb) {
  beginUntrackFrame();
  try {
    return cb();
  } finally {
    endUntrackFrame();
  }
}
function beginUntrackFrame() {
  renderingStateBeforeBegin = isRendering();
  if (renderingStateBeforeBegin) {
    setIsRendering(false);
  }
}
function endUntrackFrame() {
  if (isRendering() !== renderingStateBeforeBegin) {
    setIsRendering(renderingStateBeforeBegin);
  }
}
function valueForTag(tag) {
  return tag.value;
}
function validateTag() {
  return false;
}
const CURRENT_TAG = cell(0, "CURRENT_TAG");

const glimmerValidator = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  CURRENT_TAG,
  beginTrackFrame,
  beginUntrackFrame,
  consumeTag,
  dirtyTagFor,
  endTrackFrame,
  endUntrackFrame,
  isTracking,
  tagFor,
  tagMetaFor,
  track,
  trackedData,
  untrack,
  validateTag,
  valueForTag
}, Symbol.toStringTag, { value: 'Module' }));

function createComputeRef(fn) {
  return formula(fn);
}
function createConstRef(value, debugLabel = "ConstRef") {
  return cell(value, debugLabel);
}
function createUnboundRef(value, debugLabel = "UnboundRef") {
  return cell(value, debugLabel);
}
function createPrimitiveRef(value, debugLabel = "PrimitiveRef") {
  return cell(value, debugLabel);
}
function childRefFor(value, path) {
  return cellFor(value.value, path);
}
function valueForRef(ref) {
  return ref.value;
}
const UNDEFINED_REFERENCE = Symbol("undefined-reference");

const glimmerReference = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  UNDEFINED_REFERENCE,
  childRefFor,
  createComputeRef,
  createConstRef,
  createPrimitiveRef,
  createUnboundRef,
  valueForRef
}, Symbol.toStringTag, { value: 'Module' }));

const OWNER = Symbol("OWNER");
function getOwner(object) {
  return object[OWNER];
}
function setOwner(object, owner) {
  object[OWNER] = owner;
}
function createOwner() {
  return {};
}

const owner = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
  __proto__: null,
  OWNER,
  createOwner,
  getOwner,
  setOwner
}, Symbol.toStringTag, { value: 'Module' }));

export { cachingPrimitives as caching, owner, glimmerReference as reference, storagePrimitives as storage, glimmerValidator as validator };