Basic Data Structures (Objects, Maps, Sets) Questions

// Serialize and deserialize preserving Map and Set and nested structures.
// Throws on functions and circular references.

function serialize(obj) {
  const seen = new WeakSet();

  function transform(value) {
    // primitives
    if (value === null) return null;
    const t = typeof value;
    if (t === 'number' || t === 'string' || t === 'boolean') return value;
    if (t === 'function' || t === 'symbol' || t === 'undefined') {
      throw new TypeError('Cannot serialize functions, symbols, or undefined');
    }

    // objects (including Array, Map, Set)
    if (t === 'object') {
      if (seen.has(value)) throw new TypeError('Circular reference detected');
      seen.add(value);

      if (Array.isArray(value)) {
        const arr = value.map(transform);
        return { __type: 'Array', items: arr };
      }

      if (value instanceof Map) {
        // store entries as [keyTransformed, valueTransformed]
        const entries = [];
        for (const [k, v] of value.entries()) {
          entries.push([transform(k), transform(v)]);
        }
        return { __type: 'Map', entries };
      }

      if (value instanceof Set) {
        const values = [];
        for (const v of value.values()) values.push(transform(v));
        return { __type: 'Set', values };
      }

      // Plain object
      const out = { __type: 'Object', props: {} };
      for (const key of Object.keys(value)) {
        out.props[key] = transform(value[key]);
      }
      return out;
    }

    throw new TypeError('Unsupported type: ' + t);
  }

  return JSON.stringify(transform(obj));
}

function deserialize(str) {
  const parsed = JSON.parse(str);

  function revive(node) {
    if (node === null) return null;
    if (typeof node !== 'object') return node;

    // Recognize tagged structures
    if (!node.__type) {
      // raw object without type tag (should not occur because serialize tags objects)
      const plain = {};
      for (const k in node) plain[k] = revive(node[k]);
      return plain;
    }

    switch (node.__type) {
      case 'Array':
        return node.items.map(revive);
      case 'Map':
        return new Map(node.entries.map(([k, v]) => [revive(k), revive(v)]));
      case 'Set':
        return new Set(node.values.map(revive));
      case 'Object': {
        const obj = {};
        for (const k of Object.keys(node.props)) obj[k] = revive(node.props[k]);
        return obj;
      }
      default:
        throw new TypeError('Unknown __type: ' + node.__type);
    }
  }

  return revive(parsed);
}

// Example round-trip
const nested = {
  a: new Map([
    ['x', 1],
    [ { complexKey: true }, new Set([1, 2, { y: 3 }]) ],
  ]),
  b: [ new Set(['s']), { inner: new Map([[42, 'answer']]) } ]
};

const s = serialize(nested);
const restored = deserialize(s);

console.log('original:', nested);
console.log('stringified:', s);
console.log('restored instanceof Map?', restored.a instanceof Map); // true
console.log('restored.b[1].inner instanceof Map?', restored.b[1].inner instanceof Map); // true

// shared defaults live once
const defaultProto = {
  featureA: 0,
  featureB: 'unknown',
  metadata: Object.freeze({ source: 'sensor' }) // immutable shared object
};

// factory to create lightweight sample instances
function createSample(values = {}) {
  // create object with prototype = defaultProto
  const obj = Object.create(defaultProto);
  // assign only differing keys as own properties
  for (const [k, v] of Object.entries(values)) {
    if (v !== defaultProto[k]) obj[k] = v;
  }
  return obj;
}

// usage
const s1 = createSample({ featureA: 3.14 });
const s2 = createSample({ featureB: 'calibrated', metadata: { source: 'custom' } });
// metadata on s2 becomes own property because it differs

// freezeFeature.js
function freezeFeature(obj, paths = []) {
  if (typeof obj !== 'object' || obj === null) {
    throw new TypeError('First arg must be a non-null object');
  }

  for (const rawPath of paths) {
    const parts = String(rawPath).split('.');
    let cur = obj;

    // traverse to the parent of the final key
    for (let i = 0; i < parts.length - 1; i++) {
      if (cur && typeof cur === 'object' && parts[i] in cur) {
        cur = cur[parts[i]];
      } else {
        // path doesn't exist; skip
        console.warn(`Path "${rawPath}" not found — skipping.`);
        cur = null;
        break;
      }
    }
    if (!cur) continue;

    const key = parts[parts.length - 1];
    if (!(key in cur)) {
      console.warn(`Property "${rawPath}" not found on target — skipping.`);
      continue;
    }

    // define non-writable, non-configurable but keep enumerable and current value
    const current = Object.getOwnPropertyDescriptor(cur, key) || {
      value: cur[key],
      writable: true,
      configurable: true,
      enumerable: true,
    };

    Object.defineProperty(cur, key, {
      value: current.value,
      writable: false,
      configurable: false,
      enumerable: current.enumerable !== false, // preserve enumerable unless explicitly false
    });
  }
}

const modelMeta = {
  name: 'spam-detector-v1',
  accuracy: 0.92,
  metadata: { createdAt: '2025-01-10', owner: 'team-ml' }
};

freezeFeature(modelMeta, ['name', 'metadata.createdAt']);

// attempts to change frozen keys
try { modelMeta.name = 'hacked'; } catch(e) {}
modelMeta.metadata.createdAt = '2099-01-01'; // silent fail in non-strict mode

console.log(modelMeta.name); // 'spam-detector-v1'
console.log(modelMeta.metadata.createdAt); // '2025-01-10'

// JSON.stringify still includes frozen keys
console.log(JSON.stringify(modelMeta));
// -> {"name":"spam-detector-v1","accuracy":0.92,"metadata":{"createdAt":"2025-01-10","owner":"team-ml"}}

// run in child process; run Node with --expose-gc
const {performance, PerformanceObserver} = require('perf_hooks');

function buildData(n){
  const keys = Array.from({length:n}, (_,i)=>`k${i}`);
  const obj = Object.create(null);
  const map = new Map();
  for(const k of keys){ obj[k]=k; map.set(k,k); }
  return {keys, obj, map};
}

function warmup(getFn, keys, durationMs=5000){
  const end = performance.now()+durationMs;
  let i=0;
  while(performance.now()<end){
    getFn(keys[i%keys.length]);
    i++;
  }
}

function measure(getFn, keys, iterations){
  const latencies = new Float64Array(iterations);
  const t0 = performance.now();
  for(let i=0;i<iterations;i++){
    const s = performance.now();
    getFn(keys[i%keys.length]);
    latencies[i] = performance.now()-s;
  }
  const t1 = performance.now();
  return {opsPerSec: iterations/((t1-t0)/1000), latencies: Array.from(latencies)};
}

function snapshotMemory(){ return process.memoryUsage(); }

// main
const {keys,obj,map} = buildData(1_000_000);
global.gc(); warmup(k=>obj[k], keys); warmup(k=>map.get(k), keys);
global.gc(); const before = snapshotMemory();
const r1 = measure(k=>obj[k], keys, 200_000);
global.gc(); const after1 = snapshotMemory();
global.gc(); const r2 = measure(k=>map.get(k), keys, 200_000);
global.gc(); const after2 = snapshotMemory();
// emit results, GC counts can be collected by PerformanceObserver if enabled