@neodx/vfs/cjs/_internal/operations-DJhEnMA2.cjs

Simple virtual file system - working dir context, lazy changes, different modes, integrations and moreover

var e = require('@neodx/colors'),
  t = require('@neodx/std'),
  r = require('pathe');
const a = (e, t, r = !1) => ({
    isFile: () => t,
    isDirectory: () => !t,
    isSymbolicLink: () => r,
    name: e
  }),
  n = e => (e.endsWith('/') ? e : `${e}/`),
  i = (e, t) => e.startsWith(n(t)),
  s = e => t => i(t, e);
function l(e, a = '') {
  let n = {};
  for (let [i, s] of t.entries(e)) {
    let e = r.join(a, i);
    t.isTypeOfString(s) ? (n[e] = s) : Object.assign(n, l(s, e));
  }
  return n;
}
async function o(e, t = '.') {
  let r = e.get(t);
  return (
    e.log.debug('Check exists %s', x(e, t)),
    !k(e, t) &&
      (!!r ||
        e.getRelativeChanges(t).filter(e => !e.deleted).length > 0 ||
        (await e.backend.exists(t)))
  );
}
async function c(e, t = '.') {
  let r = e.get(t);
  return r ? !r.deleted : await e.backend.isFile(t);
}
async function d(e, t = '.') {
  return e.getRelativeChanges(t).some(e => !e.deleted) || (await e.backend.isDir(t));
}
async function u(e, n = '.') {
  e.log.debug('Read dir %s', x(e, n));
  let i = await e.backend.readDir(n),
    s = e.getRelativeChanges(n),
    l = t => !k(e, t),
    o = e.resolve(n),
    c = t => r.relative(o, e.resolve(t)).split(r.sep)[0];
  return t.uniqBy(
    [
      ...i.filter(t => l(e.resolve(n, t.name))),
      ...s
        .filter(e => l(e.path))
        .map(e => a(c(e.path), !0))
        .filter(e => !!e.name.replaceAll('.', ''))
    ],
    e => e.name
  );
}
async function f(e, t, r) {
  if ((e.log.debug('Read %s', x(e, t)), !(await c(e, t)))) return null;
  let a = e.get(t)?.content ?? (await e.backend.read(t));
  return r ? a.toString(r) : a;
}
async function p(e, t, r) {
  let a = await f(e, t, r);
  if (null === a) throw Error(`"${t}" is not file`);
  return a;
}
async function g(e, t, a) {
  e.log.debug('Write %s', x(e, t));
  let n = await w(e, t);
  (function e(t, a) {
    let n = r.dirname(a);
    n !== a && (t.unregister(n), e(t, n));
  })(e, e.resolve(t)),
    n && Buffer.from(a).equals(n) ? e.unregister(t) : e.writePathContent(t, a);
}
async function y(e, t) {
  for (let r of (e.log.debug('Delete %s', x(e, t)), e.deletePath(t, !0), e.getRelativeChanges(t)))
    e.unregister(r.path);
  let a = r.dirname(e.resolve(t));
  0 === (await u(e, a)).length && (await y(e, a));
}
async function h(e, r, ...a) {
  if ((e.log.debug('Rename %s to %s', x(e, r), a.map(t => x(e, t)).join(', ')), !(await o(e, r)))) {
    e.log.debug('Path %s not exists, rename skipped', x(e, r));
    return;
  }
  let n = await p(e, r);
  await y(e, r), await t.concurrently(a, t => g(e, t, n), 5);
}
async function m(e, r) {
  let a = await t.concurrently(
    e.getAllDirectChanges(),
    async ({ path: t, deleted: r, content: a, ...n }) => {
      let i = await e.backend.exists(t);
      return r && !i
        ? null
        : r
          ? { ...n, path: t, type: 'delete' }
          : { ...n, path: t, type: i ? 'update' : 'create', content: a };
    }
  );
  return r ? a.filter(e => t.isTruthy(e) && r.includes(e.type)) : t.compact(a);
}
async function w(e, t) {
  let r = e.resolve(t);
  return (await e.backend.isFile(r)) ? await e.backend.read(r) : null;
}
const x = (t, a) => {
    let n =
      t.path.length > v ? `${t.path.slice(0, v / 4)}...${t.path.slice(-(3 * v) / 4)}` : t.path;
    return `${e.colors.gray(n + r.sep)}${t.relative(a)}`;
  },
  b = (e, t) => e.get(t)?.deleted,
  k = (e, t) =>
    b(e, t) ||
    e
      .relative(t)
      .split('/')
      .filter(e => !e.startsWith('.'))
      .some(t => b(e, t)),
  v = 28;
(exports.createInMemoryBackend = function (e = '/', o = {}) {
  let c = new Map(t.entries(l(o, e)).map(([e, t]) => [e, Buffer.from(t)])),
    d = new Set(),
    u = e => c.has(e),
    f = e => !u(e) && Array.from(c.keys()).some(s(e)),
    p = e => {
      c.delete(e), d.add(e);
    };
  return {
    read: e => c.get(e) ?? null,
    isFile: u,
    isDir: f,
    exists: e => u(e) || f(e),
    readDir: e =>
      t
        .uniq(
          Array.from(c.keys())
            .filter(s(e))
            .map(t => t.split(n(e))[1].split('/')[0])
        )
        .map(t => a(t, u(r.join(e, t)))),
    write(e, t) {
      for (c.set(e, Buffer.from(t)); '/' !== e; ) d.delete(e), (e = r.dirname(e));
    },
    delete(e) {
      for (let t of (p(e), c.keys())) i(t, e) && p(t);
    },
    __: { kind: 'in-memory', getStore: () => new Map(c), getDeleted: () => new Set(d) }
  };
}),
  (exports.createInMemoryFilesRecord = l),
  (exports.deleteVfsPath = y),
  (exports.displayPath = x),
  (exports.existsVfsPath = o),
  (exports.getVfsActions = m),
  (exports.isVfsDir = d),
  (exports.isVfsFile = c),
  (exports.pathStartsWith = i),
  (exports.readVfsDir = u),
  (exports.readVfsFile = p),
  (exports.renameVfs = h),
  (exports.tryReadVfsFile = f),
  (exports.writeVfsFile = g);
//# sourceMappingURL=operations-DJhEnMA2.cjs.map