@ps-generator-bridge/generator 0.1.0

package/jsx/Selection/pathtosvg.jsx

@@ -0,0 +1,257 @@
+Array.prototype.map = function (f) {
+  var retArr = [];
+  for (var i = 0, e = this.length; i < e; i++) {
+    retArr[i] = f(this[i], i);
+  }
+  return retArr;
+};
+
+Array.prototype.forEach = function (f) {
+  this.map(f);
+};
+
+Array.from = function (iterable) {
+  var retArr = [];
+  for (var i = 0, e = iterable.length; i < e; i++) {
+    retArr.push(iterable[i]);
+  }
+  return retArr;
+};
+
+//
+// Also we'll need some custom objects.
+//
+
+var Point = function (kind, x, y) {
+  this.kind = kind;
+  this.x = x;
+  this.y = y;
+};
+
+Point.prototype = {
+  toString: function () {
+    var base = [this.kind];
+    if (this.in) {
+      base = base.concat(["(", this.in.x, this.in.y, ")"]);
+    }
+    base = base.concat([this.x, this.y]);
+    if (this.out) {
+      base = base.concat(["(", this.out.x, this.out.y, ")"]);
+    }
+    return base.join(" ");
+  },
+};
+
+var BBox = function () {
+  this.mx = null;
+  this.my = null;
+  this.MX = null;
+  this.MY = null;
+  this.initialized = false;
+};
+
+BBox.prototype = {
+  grow: function (p) {
+    if (!p || p.x === undefined || p.y === undefined) return;
+
+    if (!this.initialized) {
+      this.mx = p.x;
+      this.my = p.y;
+      this.MX = p.x;
+      this.MY = p.y;
+      this.initialized = true;
+    } else {
+      if (p.x < this.mx) {
+        this.mx = p.x;
+      }
+      if (p.y < this.my) {
+        this.my = p.y;
+      }
+      if (p.x > this.MX) {
+        this.MX = p.x;
+      }
+      if (p.y > this.MY) {
+        this.MY = p.y;
+      }
+    }
+
+    // 也要考虑控制点
+    this.grow(p.in);
+    this.grow(p.out);
+  },
+};
+
+//
+// And with that out of the way, the actual script:
+//
+
+var pointTypes = {
+  "PointKind.CORNERPOINT": "P",
+  "PointKind.SMOOTHPOINT": "C",
+};
+
+// filewrite function
+function writeToFile(data) {
+  var path = "/";
+  // can we get a file location from the current document?
+  try {
+    path = app.activeDocument.path;
+  } catch (e) {}
+  var dir = Folder(path);
+  var file = dir.saveDlg("", ".svg", true);
+  if (!file) return false;
+
+  var mode = "w";
+  file.open(mode);
+  file.write(data);
+  file.close(mode);
+  return file.toString();
+}
+
+// convert a PathPoint to a real object.
+function improvePoint(point) {
+  var kind = pointTypes[point.kind];
+  var coord = point.anchor;
+  var x = Math.round(coord[0]);
+  var y = Math.round(coord[1]);
+  var obj = new Point(kind, x, y);
+
+  if (kind === "C") {
+    var d;
+    if (point.leftDirection) {
+      d = point.leftDirection.map(Math.round);
+      obj.out = { x: d[0], y: d[1] };
+    }
+    if (point.rightDirection) {
+      d = point.rightDirection.map(Math.round);
+      obj.in = { x: d[0], y: d[1] };
+    }
+  }
+
+  return obj;
+}
+
+// convert all points in a subpath to easier to parse form
+function handleSubPath(subpath) {
+  var pathPoints = Array.from(subpath.pathPoints);
+  return pathPoints.map(improvePoint);
+}
+
+// convert all subpaths in a path to easier to walk form
+function handlePath(path) {
+  var subPaths = Array.from(path.subPathItems);
+  return subPaths.map(handleSubPath);
+}
+
+// convert only the first path in a document to easier to walk form.
+function convertLastedPath(pathItems) {
+  if (pathItems.length === 0) {
+    return null;
+  }
+  // 只获取第一个路径
+  var lastedPath = pathItems[pathItems.length - 1];
+  return handlePath(lastedPath);
+}
+
+// turn a subpath of improved points into an SVG path
+function formSVGpath(subpath, bbox) {
+  var p0 = subpath[0];
+  var path = ["M", p0.x, p0.y];
+
+  // 确保第一个点也被计算进边界框
+  bbox.grow(p0);
+
+  // we want to close this path:
+  subpath.push(p0);
+  subpath.forEach(function (p, i) {
+    if (i === 0) return;
+    bbox.grow(p);
+
+    if (p0.kind === "P" && p.kind === "P") {
+      path = path.concat(["L", p.x, p.y]);
+    } else if (p0.kind === "P" && p.kind === "C") {
+      path = path.concat(["C", p0.x, p0.y, p.in.x, p.in.y, p.x, p.y]);
+    } else if (p0.kind === "C" && p.kind === "P") {
+      path = path.concat(["C", p0.out.x, p0.out.y, p.x, p.y, p.x, p.y]);
+    } else if (p0.kind === "C" && p.kind === "C") {
+      path = path.concat(["C", p0.out.x, p0.out.y, p.in.x, p.in.y, p.x, p.y]);
+    }
+    p0 = p;
+  });
+  path.push("z");
+  return path.join(" ");
+}
+
+// Convert a single improved path into an SVG string with tight bounding box
+function formSinglePathSVG(singlePath) {
+  if (!singlePath) {
+    return '<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"></svg>';
+  }
+
+  var svg = [];
+  var bbox = new BBox();
+  var d = "";
+
+  // 处理单个路径的所有子路径
+  singlePath.forEach(function (subpath) {
+    d += formSVGpath(subpath, bbox);
+  });
+
+  // 检查边界框是否有效
+  if (!bbox.initialized) {
+    return '<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"></svg>';
+  }
+
+  // 计算精确的宽高，完全贴合形状
+  var w = bbox.MX - bbox.mx;
+  var h = bbox.MY - bbox.my;
+
+  // 确保宽高至少为1，避免无效的SVG
+  w = Math.max(w, 1);
+  h = Math.max(h, 1);
+
+  svg.push(
+    '<path fill="none" stroke="#25b048" stroke-width="2" fill-rule="evenodd" d="' + d + '"/>'
+  );
+  svg.push("</svg>");
+
+  var header =
+    '<svg xmlns="http://www.w3.org/2000/svg" width="' +
+    Math.round(w) +
+    '" height="' +
+    Math.round(h) +
+    '" viewBox="' +
+    [bbox.mx, bbox.my, w, h].join(" ") +
+    '">';
+  svg = [header].concat(svg);
+  return svg.join("\n");
+}
+
+// ===========================================
+//
+//           JS equivalent of main()
+//
+// ===========================================
+
+// #target photoshop;
+
+// switch to using pixels as unit, irrespective of what the document is set to
+var activeDoc = app.activeDocument;
+var origUnits = app.preferences.rulerUnits;
+app.preferences.rulerUnits = Units.PIXELS;
+
+// 检查是否有工作路径
+if (activeDoc.pathItems.length === 0) {
+  app.preferences.rulerUnits = origUnits;
+  throw new Error("没有找到工作路径");
+}
+
+// 只转换第一个路径
+var firstPathImproved = convertLastedPath(activeDoc.pathItems);
+var svg = formSinglePathSVG(firstPathImproved);
+
+// switch back to the original document's units once we're done.
+app.preferences.rulerUnits = origUnits;
+
+// 返回 SVG 字符串
+svg;

package/jsx/Selection/registerEvent.jsx

@@ -0,0 +1,10 @@
+var events = params.events;
+
+var actionDescriptor = new ActionDescriptor();
+actionDescriptor.putString(stringIDToTypeID("version"), "1.0.0");
+
+for (var i = 0; i < events.length; i++) {
+  // 这里要指定生成的那个扩展ID
+  actionDescriptor.putClass(stringIDToTypeID("eventIDAttr"), charIDToTypeID(events[i]));
+  executeAction(stringIDToTypeID("networkEventSubscribe"), actionDescriptor, DialogModes.NO);
+}

package/jsx/Selection/selectiontopath.jsx

@@ -0,0 +1,9 @@
+var desc1 = new ActionDescriptor();
+var ref1 = new ActionReference();
+ref1.putClass(charIDToTypeID("Path"));
+desc1.putReference(charIDToTypeID("null"), ref1);
+var ref2 = new ActionReference();
+ref2.putProperty(charIDToTypeID("csel"), charIDToTypeID("fsel"));
+desc1.putReference(charIDToTypeID("From"), ref2);
+desc1.putUnitDouble(charIDToTypeID("Tlrn"), charIDToTypeID("#Pxl"), 1.0);
+executeAction(charIDToTypeID("Mk  "), desc1, DialogModes.NO);

package/jsx/polyfills/Array.js

@@ -0,0 +1,159 @@
+//#region Array Polyfills (ES3 compatible)
+
+// Array.isArray
+if (!Array.isArray) {
+  Array.isArray = function (arg) {
+    return Object.prototype.toString.call(arg) === "[object Array]";
+  };
+}
+
+// Array.prototype.indexOf
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function (searchElement, fromIndex) {
+    var len = this.length >>> 0;
+    var i = Number(fromIndex) || 0;
+    if (i < 0) {
+      i = Math.max(len + i, 0);
+    }
+    for (; i < len; i++) {
+      if (i in this && this[i] === searchElement) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+
+// Array.prototype.forEach
+if (!Array.prototype.forEach) {
+  Array.prototype.forEach = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    for (var i = 0; i < len; i++) {
+      if (i in this) {
+        callback.call(thisArg, this[i], i, this);
+      }
+    }
+  };
+}
+
+// Array.prototype.map
+if (!Array.prototype.map) {
+  Array.prototype.map = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    var result = new Array(len);
+    for (var i = 0; i < len; i++) {
+      if (i in this) {
+        result[i] = callback.call(thisArg, this[i], i, this);
+      }
+    }
+    return result;
+  };
+}
+
+// Array.prototype.filter
+if (!Array.prototype.filter) {
+  Array.prototype.filter = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    var result = [];
+    for (var i = 0; i < len; i++) {
+      if (i in this) {
+        var val = this[i];
+        if (callback.call(thisArg, val, i, this)) {
+          result.push(val);
+        }
+      }
+    }
+    return result;
+  };
+}
+
+// Array.prototype.reduce
+if (!Array.prototype.reduce) {
+  Array.prototype.reduce = function (callback, initialValue) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    var i = 0;
+    var accumulator;
+    if (arguments.length >= 2) {
+      accumulator = initialValue;
+    } else {
+      while (i < len && !(i in this)) {
+        i++;
+      }
+      if (i >= len) {
+        throw new TypeError("Reduce of empty array with no initial value");
+      }
+      accumulator = this[i++];
+    }
+    for (; i < len; i++) {
+      if (i in this) {
+        accumulator = callback(accumulator, this[i], i, this);
+      }
+    }
+    return accumulator;
+  };
+}
+
+// Array.prototype.some
+if (!Array.prototype.some) {
+  Array.prototype.some = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    for (var i = 0; i < len; i++) {
+      if (i in this && callback.call(thisArg, this[i], i, this)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
+// Array.prototype.every
+if (!Array.prototype.every) {
+  Array.prototype.every = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    for (var i = 0; i < len; i++) {
+      if (i in this && !callback.call(thisArg, this[i], i, this)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+// Array.prototype.find
+if (!Array.prototype.find) {
+  Array.prototype.find = function (callback, thisArg) {
+    if (typeof callback !== "function") {
+      throw new TypeError(callback + " is not a function");
+    }
+    var len = this.length >>> 0;
+    for (var i = 0; i < len; i++) {
+      if (i in this) {
+        var val = this[i];
+        if (callback.call(thisArg, val, i, this)) {
+          return val;
+        }
+      }
+    }
+    return undefined;
+  };
+}
+
+//#endregion

package/jsx/polyfills/Function.js

@@ -0,0 +1,29 @@
+//#region Function Polyfills (ES3 compatible)
+
+// Function.prototype.bind
+if (!Function.prototype.bind) {
+  Function.prototype.bind = function (oThis) {
+    if (typeof this !== "function") {
+      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
+    }
+
+    var aArgs = Array.prototype.slice.call(arguments, 1);
+    var fToBind = this;
+    var fNOP = function () {};
+    var fBound = function () {
+      return fToBind.apply(
+        fNOP.prototype && this instanceof fNOP ? this : oThis,
+        aArgs.concat(Array.prototype.slice.call(arguments))
+      );
+    };
+
+    if (this.prototype) {
+      fNOP.prototype = this.prototype;
+    }
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+
+//#endregion

package/jsx/polyfills/JSON.js

@@ -0,0 +1,182 @@
+//#region JSON
+
+// JSON
+if (typeof JSON !== "object") {
+  JSON = {};
+
+  (function () {
+    "use strict";
+
+    var rx_one = /^[\],:{}\s]*$/;
+    var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
+    var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
+    var rx_four = /(?:^|:|,)(?:\s*\[)+/g;
+    var rx_escapable =
+      /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+    var rx_dangerous =
+      /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+
+    function f(n) {
+      // Format integers to have at least two digits.
+      return n < 10 ? "0" + n : n;
+    }
+
+    function this_value() {
+      return this.valueOf();
+    }
+
+    if (typeof Date.prototype.toJSON !== "function") {
+      Date.prototype.toJSON = function () {
+        return isFinite(this.valueOf())
+          ? this.getUTCFullYear() +
+              "-" +
+              f(this.getUTCMonth() + 1) +
+              "-" +
+              f(this.getUTCDate()) +
+              "T" +
+              f(this.getUTCHours()) +
+              ":" +
+              f(this.getUTCMinutes()) +
+              ":" +
+              f(this.getUTCSeconds()) +
+              "Z"
+          : null;
+      };
+
+      Boolean.prototype.toJSON = this_value;
+      Number.prototype.toJSON = this_value;
+      String.prototype.toJSON = this_value;
+    }
+
+    var gap;
+    var indent;
+    var meta;
+    var rep;
+
+    function quote(string) {
+      rx_escapable.lastIndex = 0;
+      return rx_escapable.test(string)
+        ? '"' +
+            string.replace(rx_escapable, function (a) {
+              var c = meta[a];
+              return typeof c === "string"
+                ? c
+                : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+            }) +
+            '"'
+        : '"' + string + '"';
+    }
+
+    function str(key, holder) {
+      var i; // The loop counter.
+      var k; // The member key.
+      var v; // The member value.
+      var length;
+      var mind = gap;
+      var partial;
+      var value = holder[key];
+
+      if (value && typeof value === "object" && typeof value.toJSON === "function") {
+        value = value.toJSON(key);
+      }
+      if (typeof rep === "function") {
+        value = rep.call(holder, key, value);
+      }
+      switch (typeof value) {
+        case "string":
+          return quote(value);
+
+        case "number":
+          return isFinite(value) ? String(value) : "null";
+
+        case "boolean":
+        case "null":
+          return String(value);
+        case "object":
+          if (!value) {
+            return "null";
+          }
+          gap += indent;
+          partial = [];
+          if (Object.prototype.toString.apply(value) === "[object Array]") {
+            length = value.length;
+            for (i = 0; i < length; i += 1) {
+              partial[i] = str(i, value) || "null";
+            }
+            v =
+              partial.length === 0
+                ? "[]"
+                : gap
+                  ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]"
+                  : "[" + partial.join(",") + "]";
+            gap = mind;
+            return v;
+          }
+          if (rep && typeof rep === "object") {
+            length = rep.length;
+            for (i = 0; i < length; i += 1) {
+              if (typeof rep[i] === "string") {
+                k = rep[i];
+                v = str(k, value);
+                if (v) {
+                  partial.push(quote(k) + (gap ? ": " : ":") + v);
+                }
+              }
+            }
+          } else {
+            for (k in value) {
+              if (Object.prototype.hasOwnProperty.call(value, k)) {
+                v = str(k, value);
+                if (v) {
+                  partial.push(quote(k) + (gap ? ": " : ":") + v);
+                }
+              }
+            }
+          }
+          v =
+            partial.length === 0
+              ? "{}"
+              : gap
+                ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}"
+                : "{" + partial.join(",") + "}";
+          gap = mind;
+          return v;
+      }
+    }
+    if (typeof JSON.stringify !== "function") {
+      meta = {
+        // table of character substitutions
+        "\b": "\\b",
+        "\t": "\\t",
+        "\n": "\\n",
+        "\f": "\\f",
+        "\r": "\\r",
+        '"': '\\"',
+        "\\": "\\\\",
+      };
+      JSON.stringify = function (value, replacer, space) {
+        var i;
+        gap = "";
+        indent = "";
+        if (typeof space === "number") {
+          for (i = 0; i < space; i += 1) {
+            indent += " ";
+          }
+        } else if (typeof space === "string") {
+          indent = space;
+        }
+        rep = replacer;
+        if (
+          replacer &&
+          typeof replacer !== "function" &&
+          (typeof replacer !== "object" || typeof replacer.length !== "number")
+        ) {
+          throw new Error("JSON.stringify");
+        }
+        return str("", { "": value });
+      };
+    }
+  })();
+}
+
+//#endregion

package/jsx/polyfills/Number.js

@@ -0,0 +1,24 @@
+//#region Number Polyfills (ES3 compatible)
+
+// Number.isFinite
+if (!Number.isFinite) {
+  Number.isFinite = function (value) {
+    return typeof value === "number" && isFinite(value);
+  };
+}
+
+// Number.isNaN
+if (!Number.isNaN) {
+  Number.isNaN = function (value) {
+    return typeof value === "number" && value !== value;
+  };
+}
+
+// Number.isInteger
+if (!Number.isInteger) {
+  Number.isInteger = function (value) {
+    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+  };
+}
+
+//#endregion