samcan 0.0.2 → 0.1.0

package/dist/document/index.cjs

@@ -0,0 +1,735 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// document/index.ts
+var exports_document = {};
+__export(exports_document, {
+  z_index_of_element: () => z_index_of_element,
+  update_text_content: () => update_text_content,
+  update_stroke_spline: () => update_stroke_spline,
+  update_stroke_simplified_points: () => update_stroke_simplified_points,
+  update_stroke_points: () => update_stroke_points,
+  update_layer_visibility: () => update_layer_visibility,
+  update_layer_opacity: () => update_layer_opacity,
+  update_layer_name: () => update_layer_name,
+  update_layer_locked: () => update_layer_locked,
+  update_image_loaded: () => update_image_loaded,
+  update_image_asset_id: () => update_image_asset_id,
+  update_element_z_index: () => update_element_z_index,
+  update_element_layer_id: () => update_element_layer_id,
+  update_element_document: () => update_element_document,
+  update_element_bounds: () => update_element_bounds,
+  type_of_element: () => type_of_element,
+  text_align_right: () => text_align_right,
+  text_align_left: () => text_align_left,
+  text_align_center: () => text_align_center,
+  shape_type_rectangle: () => shape_type_rectangle,
+  shape_type_line: () => shape_type_line,
+  shape_type_frame: () => shape_type_frame,
+  shape_type_ellipse: () => shape_type_ellipse,
+  shape_type_arrow: () => shape_type_arrow,
+  set_active_layer_document: () => set_active_layer_document,
+  reorder_layers_document: () => reorder_layers_document,
+  reorder_element_ids_in_layer: () => reorder_element_ids_in_layer,
+  remove_layer_document: () => remove_layer_document,
+  remove_image_asset_document: () => remove_image_asset_document,
+  remove_element_id_from_layer: () => remove_element_id_from_layer,
+  remove_element_document: () => remove_element_document,
+  recalculate_bounds_document: () => recalculate_bounds_document,
+  opacity_of_layer: () => opacity_of_layer,
+  name_of_layer: () => name_of_layer,
+  layers_of_document: () => layers_of_document,
+  layer_id_of_element: () => layer_id_of_element,
+  is_visible_layer: () => is_visible_layer,
+  is_locked_layer: () => is_locked_layer,
+  id_of_layer: () => id_of_layer,
+  id_of_element: () => id_of_element,
+  id_of_document: () => id_of_document,
+  has_element_id_in_layer: () => has_element_id_in_layer,
+  get_layer_by_id_document: () => get_layer_by_id_document,
+  get_image_asset_document: () => get_image_asset_document,
+  get_elements_in_layer_document: () => get_elements_in_layer_document,
+  get_element_by_id_document: () => get_element_by_id_document,
+  get_all_elements_document: () => get_all_elements_document,
+  equals_layer: () => equals_layer,
+  equals_element_identity: () => equals_element_identity,
+  elements_map_of_document: () => elements_map_of_document,
+  element_type_text: () => element_type_text,
+  element_type_stroke: () => element_type_stroke,
+  element_type_shape: () => element_type_shape,
+  element_type_image: () => element_type_image,
+  element_ids_of_layer: () => element_ids_of_layer,
+  element_count_of_layer: () => element_count_of_layer,
+  element_count_of_document: () => element_count_of_document,
+  create_text_element: () => create_text_element,
+  create_stroke_element: () => create_stroke_element,
+  create_shape_element: () => create_shape_element,
+  create_layer: () => create_layer,
+  create_image_element: () => create_image_element,
+  create_image_asset: () => create_image_asset,
+  create_document: () => create_document,
+  clone_layer: () => clone_layer,
+  clone_element: () => clone_element,
+  clone_document: () => clone_document,
+  clear_document: () => clear_document,
+  bounds_of_element: () => bounds_of_element,
+  bounds_of_document: () => bounds_of_document,
+  assets_of_document: () => assets_of_document,
+  add_layer_document: () => add_layer_document,
+  add_image_asset_document: () => add_image_asset_document,
+  add_element_id_to_layer: () => add_element_id_to_layer,
+  add_element_document: () => add_element_document,
+  active_layer_id_of_document: () => active_layer_id_of_document
+});
+module.exports = __toCommonJS(exports_document);
+
+// document/asset.ts
+function create_image_asset(id, src, width = 0, height = 0) {
+  return { id, src, width, height };
+}
+// document/layer.ts
+function create_layer(id, name, visible = true, locked = false, opacity = 1) {
+  return {
+    id,
+    name,
+    visible,
+    locked,
+    opacity: Math.max(0, Math.min(1, opacity)),
+    element_ids: []
+  };
+}
+function clone_layer(l) {
+  return {
+    id: l.id,
+    name: l.name,
+    visible: l.visible,
+    locked: l.locked,
+    opacity: l.opacity,
+    element_ids: [...l.element_ids]
+  };
+}
+function id_of_layer(l) {
+  return l.id;
+}
+function name_of_layer(l) {
+  return l.name;
+}
+function is_visible_layer(l) {
+  return l.visible;
+}
+function is_locked_layer(l) {
+  return l.locked;
+}
+function opacity_of_layer(l) {
+  return l.opacity;
+}
+function element_ids_of_layer(l) {
+  return l.element_ids;
+}
+function element_count_of_layer(l) {
+  return l.element_ids.length;
+}
+function update_layer_name(l, name) {
+  return {
+    ...l,
+    name
+  };
+}
+function update_layer_visibility(l, visible) {
+  return {
+    ...l,
+    visible
+  };
+}
+function update_layer_locked(l, locked) {
+  return {
+    ...l,
+    locked
+  };
+}
+function update_layer_opacity(l, opacity) {
+  return {
+    ...l,
+    opacity: Math.max(0, Math.min(1, opacity))
+  };
+}
+function add_element_id_to_layer(l, element_id) {
+  if (l.element_ids.includes(element_id)) {
+    return l;
+  }
+  return {
+    ...l,
+    element_ids: [...l.element_ids, element_id]
+  };
+}
+function remove_element_id_from_layer(l, element_id) {
+  const index = l.element_ids.indexOf(element_id);
+  if (index === -1) {
+    return l;
+  }
+  const new_ids = [...l.element_ids];
+  new_ids.splice(index, 1);
+  return {
+    ...l,
+    element_ids: new_ids
+  };
+}
+function has_element_id_in_layer(l, element_id) {
+  return l.element_ids.includes(element_id);
+}
+function reorder_element_ids_in_layer(l, element_ids) {
+  const existing_set = new Set(l.element_ids);
+  const filtered_ids = element_ids.filter((id) => existing_set.has(id));
+  const new_ids_set = new Set(filtered_ids);
+  const remaining_ids = l.element_ids.filter((id) => !new_ids_set.has(id));
+  return {
+    ...l,
+    element_ids: [...remaining_ids, ...filtered_ids]
+  };
+}
+function equals_layer(a, b) {
+  if (a.id !== b.id || a.name !== b.name) {
+    return false;
+  }
+  if (a.visible !== b.visible || a.locked !== b.locked) {
+    return false;
+  }
+  if (a.opacity !== b.opacity) {
+    return false;
+  }
+  if (a.element_ids.length !== b.element_ids.length) {
+    return false;
+  }
+  for (let i = 0;i < a.element_ids.length; i = i + 1) {
+    if (a.element_ids[i] !== b.element_ids[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// document/document.ts
+function create_document(id, active_layer_id) {
+  return {
+    id,
+    elements: new Map,
+    layers: [],
+    active_layer_id,
+    assets: new Map,
+    bounds: [0, 0, 0, 0],
+    element_count: 0
+  };
+}
+function clone_document(doc) {
+  const new_elements = new Map;
+  for (const [id, el] of doc.elements) {
+    new_elements.set(id, el);
+  }
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: doc.layers.map((l) => ({ ...l, element_ids: [...l.element_ids] })),
+    active_layer_id: doc.active_layer_id,
+    assets: new Map(doc.assets),
+    bounds: [doc.bounds[0], doc.bounds[1], doc.bounds[2], doc.bounds[3]],
+    element_count: doc.element_count
+  };
+}
+function id_of_document(doc) {
+  return doc.id;
+}
+function elements_map_of_document(doc) {
+  return doc.elements;
+}
+function layers_of_document(doc) {
+  return doc.layers;
+}
+function active_layer_id_of_document(doc) {
+  return doc.active_layer_id;
+}
+function assets_of_document(doc) {
+  return doc.assets;
+}
+function bounds_of_document(doc) {
+  return [doc.bounds[0], doc.bounds[1], doc.bounds[2], doc.bounds[3]];
+}
+function element_count_of_document(doc) {
+  return doc.element_count;
+}
+function get_element_by_id_document(doc, element_id) {
+  return doc.elements.get(element_id) || null;
+}
+function get_layer_by_id_document(doc, layer_id) {
+  for (let i = 0;i < doc.layers.length; i = i + 1) {
+    const layer = doc.layers[i];
+    if (layer && layer.id === layer_id) {
+      return layer;
+    }
+  }
+  return null;
+}
+function add_element_document(doc, el) {
+  const layer = get_layer_by_id_document(doc, el.layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.set(el.id, el);
+  const new_layers = doc.layers.map((l) => {
+    if (l.id === el.layer_id) {
+      return add_element_id_to_layer(l, el.id);
+    }
+    return l;
+  });
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function remove_element_document(doc, element_id) {
+  const el = doc.elements.get(element_id);
+  if (el === undefined) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.delete(element_id);
+  const new_layers = doc.layers.map((l) => {
+    if (l.id === el.layer_id) {
+      return remove_element_id_from_layer(l, element_id);
+    }
+    return l;
+  });
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function update_element_document(doc, element_id, new_element) {
+  if (!doc.elements.has(element_id)) {
+    return doc;
+  }
+  const old_element = doc.elements.get(element_id);
+  if (old_element === undefined) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.set(element_id, new_element);
+  let new_layers = doc.layers;
+  if (old_element.layer_id !== new_element.layer_id) {
+    new_layers = doc.layers.map((l) => {
+      if (l.id === old_element.layer_id) {
+        return remove_element_id_from_layer(l, element_id);
+      }
+      if (l.id === new_element.layer_id) {
+        return add_element_id_to_layer(l, element_id);
+      }
+      return l;
+    });
+  }
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function add_layer_document(doc, layer) {
+  const existing = get_layer_by_id_document(doc, layer.id);
+  if (existing !== null) {
+    return doc;
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: [...doc.layers, layer],
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function remove_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  for (const element_id of layer.element_ids) {
+    new_elements.delete(element_id);
+  }
+  const new_layers = doc.layers.filter((l) => l.id !== layer_id);
+  let new_active_layer_id = doc.active_layer_id;
+  if (doc.active_layer_id === layer_id) {
+    if (new_layers.length > 0) {
+      const first_layer = new_layers[0];
+      if (first_layer !== undefined) {
+        new_active_layer_id = first_layer.id;
+      } else {
+        new_active_layer_id = "";
+      }
+    } else {
+      new_active_layer_id = "";
+    }
+  }
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: new_active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function reorder_layers_document(doc, layer_ids) {
+  const id_set = new Set(layer_ids);
+  const existing_ids = doc.layers.map((l) => l.id);
+  const missing_ids = existing_ids.filter((id) => !id_set.has(id));
+  const ordered_layers = [];
+  const layer_map = new Map(doc.layers.map((l) => [l.id, l]));
+  for (const id of layer_ids) {
+    const layer = layer_map.get(id);
+    if (layer) {
+      ordered_layers.push(layer);
+    }
+  }
+  for (const id of missing_ids) {
+    const layer = layer_map.get(id);
+    if (layer) {
+      ordered_layers.push(layer);
+    }
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: ordered_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function set_active_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: doc.layers,
+    active_layer_id: layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function get_elements_in_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return [];
+  }
+  const elements = [];
+  for (const element_id of layer.element_ids) {
+    const el = doc.elements.get(element_id);
+    if (el !== undefined) {
+      elements.push(el);
+    }
+  }
+  return elements;
+}
+function get_all_elements_document(doc) {
+  return Array.from(doc.elements.values());
+}
+function calculate_bounds_document_internal(elements) {
+  if (elements.size === 0) {
+    return [0, 0, 0, 0];
+  }
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  for (const el of elements.values()) {
+    const bounds = el.bounds;
+    min_x = Math.min(min_x, bounds[0]);
+    min_y = Math.min(min_y, bounds[1]);
+    max_x = Math.max(max_x, bounds[0] + bounds[2]);
+    max_y = Math.max(max_y, bounds[1] + bounds[3]);
+  }
+  if (min_x === Infinity) {
+    return [0, 0, 0, 0];
+  }
+  return [min_x, min_y, max_x - min_x, max_y - min_y];
+}
+function recalculate_bounds_document(doc) {
+  const new_bounds = calculate_bounds_document_internal(doc.elements);
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: doc.layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: doc.element_count
+  };
+}
+function clear_document(doc) {
+  return {
+    id: doc.id,
+    elements: new Map,
+    layers: doc.layers.map((l) => ({ ...l, element_ids: [] })),
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: [0, 0, 0, 0],
+    element_count: 0
+  };
+}
+function add_image_asset_document(doc, asset) {
+  const assets = new Map(doc.assets);
+  assets.set(asset.id, { ...asset });
+  return {
+    ...doc,
+    assets
+  };
+}
+function get_image_asset_document(doc, asset_id) {
+  return doc.assets.get(asset_id) ?? null;
+}
+function remove_image_asset_document(doc, asset_id) {
+  if (!doc.assets.has(asset_id))
+    return doc;
+  const assets = new Map(doc.assets);
+  assets.delete(asset_id);
+  return {
+    ...doc,
+    assets
+  };
+}
+// document/element.ts
+var element_type_stroke = 0;
+var element_type_shape = 1;
+var element_type_image = 2;
+var element_type_text = 3;
+var shape_type_rectangle = 0;
+var shape_type_ellipse = 1;
+var shape_type_line = 2;
+var shape_type_arrow = 3;
+var shape_type_frame = 4;
+var text_align_left = 0;
+var text_align_center = 1;
+var text_align_right = 2;
+function create_stroke_element(id, bounds, z_index, layer_id, points, pressure, color, width, group_id = null) {
+  return {
+    type: element_type_stroke,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    points: points.map((p) => [p[0], p[1]]),
+    pressure: pressure === null ? null : [...pressure],
+    color: [color[0], color[1], color[2], color[3]],
+    width,
+    simplified_points: null,
+    spline: null
+  };
+}
+function create_shape_element(id, bounds, z_index, layer_id, shape_type, fill_color, stroke_color, stroke_width, start_point, end_point, group_id = null) {
+  return {
+    type: element_type_shape,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    shape_type,
+    fill_color: fill_color === null ? null : [fill_color[0], fill_color[1], fill_color[2], fill_color[3]],
+    stroke_color: stroke_color === null ? null : [stroke_color[0], stroke_color[1], stroke_color[2], stroke_color[3]],
+    stroke_width,
+    start_point: start_point === null ? null : [start_point[0], start_point[1]],
+    end_point: end_point === null ? null : [end_point[0], end_point[1]]
+  };
+}
+function create_image_element(id, bounds, z_index, layer_id, src, original_width, original_height, opacity, group_id = null, asset_id = null) {
+  return {
+    type: element_type_image,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    asset_id,
+    src,
+    original_width,
+    original_height,
+    opacity,
+    loaded: false,
+    load_error: false,
+    bitmap: null
+  };
+}
+function create_text_element(id, bounds, z_index, layer_id, content, font_family, font_size, color, align, group_id = null) {
+  return {
+    type: element_type_text,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    content,
+    font_family,
+    font_size,
+    color: [color[0], color[1], color[2], color[3]],
+    align
+  };
+}
+function clone_element(el) {
+  if (el.type === element_type_stroke) {
+    const stroke = el;
+    return create_stroke_element(stroke.id, stroke.bounds, stroke.z_index, stroke.layer_id, stroke.points, stroke.pressure, stroke.color, stroke.width, stroke.group_id);
+  } else if (el.type === element_type_shape) {
+    const shape = el;
+    return create_shape_element(shape.id, shape.bounds, shape.z_index, shape.layer_id, shape.shape_type, shape.fill_color, shape.stroke_color, shape.stroke_width, shape.start_point, shape.end_point, shape.group_id);
+  } else if (el.type === element_type_image) {
+    const image = el;
+    const cloned = create_image_element(image.id, image.bounds, image.z_index, image.layer_id, image.src, image.original_width, image.original_height, image.opacity, image.group_id, image.asset_id);
+    cloned.loaded = image.loaded;
+    cloned.load_error = image.load_error;
+    cloned.bitmap = image.bitmap;
+    return cloned;
+  } else {
+    const text = el;
+    return create_text_element(text.id, text.bounds, text.z_index, text.layer_id, text.content, text.font_family, text.font_size, text.color, text.align, text.group_id);
+  }
+}
+function id_of_element(el) {
+  return el.id;
+}
+function bounds_of_element(el) {
+  return [el.bounds[0], el.bounds[1], el.bounds[2], el.bounds[3]];
+}
+function z_index_of_element(el) {
+  return el.z_index;
+}
+function layer_id_of_element(el) {
+  return el.layer_id;
+}
+function type_of_element(el) {
+  return el.type;
+}
+function update_element_bounds(el, bounds) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.bounds = [bounds[0], bounds[1], bounds[2], bounds[3]];
+  return cloned;
+}
+function update_element_z_index(el, z_index) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.z_index = z_index;
+  return cloned;
+}
+function update_element_layer_id(el, layer_id) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.layer_id = layer_id;
+  return cloned;
+}
+function update_stroke_points(el, points) {
+  return {
+    ...el,
+    points: points.map((p) => [p[0], p[1]]),
+    simplified_points: null,
+    spline: null
+  };
+}
+function update_stroke_simplified_points(el, simplified) {
+  return {
+    ...el,
+    simplified_points: simplified === null ? null : simplified.map((p) => [p[0], p[1]])
+  };
+}
+function update_stroke_spline(el, spline_data) {
+  return {
+    ...el,
+    spline: spline_data
+  };
+}
+function update_image_loaded(el, loaded, bitmap, load_error = false) {
+  return {
+    ...el,
+    loaded,
+    load_error,
+    bitmap
+  };
+}
+function update_image_asset_id(el, asset_id) {
+  return {
+    ...el,
+    asset_id
+  };
+}
+function update_text_content(el, content) {
+  return {
+    ...el,
+    content
+  };
+}
+function equals_element_identity(a, b) {
+  if (a.type !== b.type || a.id !== b.id) {
+    return false;
+  }
+  if (a.z_index !== b.z_index || a.layer_id !== b.layer_id) {
+    return false;
+  }
+  if (a.group_id !== b.group_id) {
+    return false;
+  }
+  if (a.bounds[0] !== b.bounds[0] || a.bounds[1] !== b.bounds[1] || a.bounds[2] !== b.bounds[2] || a.bounds[3] !== b.bounds[3]) {
+    return false;
+  }
+  return true;
+}