@rgsoft/lsystem 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ricardo Miranda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# Turtle
+
+Turtle and L-Systems library
+
+## L-Systems
+
+The `LSystem` class is an implementation of the
+[Lindenmayer systems](https://en.wikipedia.org/wiki/L-system) based on an
+alphabet of symbols and production rules.
+
+```js
+const lsystem = new LSystem(axiom, rules);
+```
+
+The `axiom` is the base sentence from which future sentences will be generated
+or inferred, and must be composed only by symbols of a defined alphabet.
+
+The `rules` is an instance of `Map`, where each entry defines a
+**production rule** for spawning the next generation sentence.
+
+### Generation
+
+The `generate` method in the `LSystem` class spawns new generations of the
+current sentence.
+
+```js
+const axiom = 'F';
+const rules = new Map([
+  ['F', ['F', '[', '+', 'F', ']', '[', '-', 'G', ']']]
+]);
+const lsystem = new LSystem(axiom, rules);
+console.log(lsystem.sentence); // F
+lsystem.generate();
+console.log(lsystem.sentence); // F[+F][-G]
+```
+
+This method also admits a number argument that indicates the number of
+generations to generate.
+
+```js
+const axiom = 'F';
+const rules = new Map([
+  ['F', ['F', 'G']]
+]);
+const lsystem = new LSystem(axiom, rules);
+console.log(lsystem.sentence); // F
+lsystem.generate(4);
+console.log(lsystem.sentence); // FGGGG
+```
+
+### Rules
+
+Each entry in the rules map representa a production rule that allows the
+generation from a symbol to an array of one or more symbols from the alphabet.
+The `parseRules` is a util function receives an array of strings in the format
+`Symbol=>Symbol+`, and returns a Map with the inferred entries.
+
+```js
+const str = 'F => FG';
+const rules = parseRules[ str ];
+console.log(rules.get('F')); // ['F', 'G']
+const definitions = ['F : FFFFGH'];
+parseRules(definitions); // Throws "Invalid rule: F : FFFFGH"
+```
+
+Alternatively, it accepts a second parameter `alphabet`, that specifies the
+list of valid symbols.
+
+```js
+const definitions = ['F => FFFFGH'];
+const alphabet = ['F', 'G'];
+parseRules(definitions, alphabet) // Throws 'Unknown symbol "H" in rule: F => FFFFGH'
+```

package/dist/index.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LSystem: () => LSystem,
+  parseRules: () => parseRules
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lsystem.ts
+var LSystem = class {
+  constructor(_axiom, _rules) {
+    this._axiom = _axiom;
+    this._rules = _rules;
+    this._generation = 0;
+    this._sentence = [..._axiom];
+  }
+  /**
+   *
+   * @param { number } n Number of generations to generate
+   * @returns { string } The generated sentence
+   */
+  generate(n = 1) {
+    let sentence = [...this._sentence];
+    for (let i = 0; i < n; i++) {
+      sentence = sentence.flatMap((s) => this._rules.get(s) ?? [s]);
+      this._generation++;
+    }
+    this._sentence = sentence;
+    return this._sentence.join("");
+  }
+  get sentence() {
+    return this._sentence.join("");
+  }
+  get generation() {
+    return this._generation;
+  }
+  get axiom() {
+    return [...this._axiom];
+  }
+  get rules() {
+    return this._rules;
+  }
+  reset() {
+    this._sentence = [...this._axiom];
+    this._generation = 0;
+  }
+};
+
+// src/utils.ts
+function parseRules(definitions, alphabet) {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    const [left, right] = def.replace(/\s+/g, "").split("=>");
+    if (!left || !right) {
+      throw new Error(`Invalid rule: ${def}`);
+    }
+    const lhs = left;
+    const rhs = right.split("");
+    if (alphabet) {
+      if (!alphabet.includes(lhs)) {
+        throw new Error(`Unknown symbol "${lhs}" in rule: ${def}`);
+      }
+      for (const s of rhs) {
+        if (!alphabet.includes(s)) {
+          throw new Error(`Unknown symbol "${s}" in rule: ${def}`);
+        }
+      }
+    }
+    map.set(lhs, rhs);
+  }
+  return map;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LSystem,
+  parseRules
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/lsystem.ts","../src/utils.ts"],"sourcesContent":["export { LSystem } from './lsystem';\r\nexport { parseRules } from './utils';\r\n","export class LSystem<Symbol extends string = string> {\r\n  private _sentence: Symbol[];\r\n  private _generation: number = 0;\r\n\r\n  constructor(\r\n    private readonly _axiom: Symbol[],\r\n    private readonly _rules: Map<Symbol, Symbol[]>\r\n  ) {\r\n    this._sentence = [..._axiom];\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param { number } n Number of generations to generate\r\n   * @returns { string } The generated sentence\r\n   */\r\n  generate(n: number = 1): string {\r\n    let sentence = [...this._sentence];\r\n    for (let i = 0; i < n; i++) {\r\n      sentence = sentence.flatMap((s) => this._rules.get(s) ?? [s]);\r\n      this._generation++;\r\n    }\r\n    this._sentence = sentence;\r\n    return this._sentence.join(\"\");\r\n  }\r\n\r\n  get sentence(): string {\r\n    return this._sentence.join(\"\");\r\n  }\r\n\r\n  get generation(): number {\r\n    return this._generation;\r\n  }\r\n\r\n  get axiom(): Symbol[] {\r\n    return [...this._axiom];\r\n  }\r\n\r\n  get rules(): Map<Symbol, Symbol[]> {\r\n    return this._rules;\r\n  }\r\n\r\n  reset(): void {\r\n    this._sentence = [...this._axiom];\r\n    this._generation = 0;\r\n  }\r\n}\r\n","export function parseRules<Symbol extends string>(\r\n  definitions: string[],\r\n  alphabet?: readonly Symbol[]\r\n): Map<Symbol, Symbol[]> {\r\n  const map = new Map<Symbol, Symbol[]>();\r\n\r\n  for (const def of definitions) {\r\n    const [left, right] = def.replace(/\\s+/g, \"\").split(\"=>\");\r\n    if (!left || !right) {\r\n      throw new Error(`Invalid rule: ${def}`);\r\n    }\r\n\r\n    const lhs = left as Symbol;\r\n    const rhs = right.split(\"\") as Symbol[];\r\n\r\n    if (alphabet) {\r\n      if (!alphabet.includes(lhs)) {\r\n        throw new Error(`Unknown symbol \"${lhs}\" in rule: ${def}`);\r\n      }\r\n      for (const s of rhs) {\r\n        if (!alphabet.includes(s)) {\r\n          throw new Error(`Unknown symbol \"${s}\" in rule: ${def}`);\r\n        }\r\n      }\r\n    }\r\n\r\n    map.set(lhs, rhs);\r\n  }\r\n\r\n  return map;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,UAAN,MAA8C;AAAA,EAInD,YACmB,QACA,QACjB;AAFiB;AACA;AAJnB,SAAQ,cAAsB;AAM5B,SAAK,YAAY,CAAC,GAAG,MAAM;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAS,IAAY,GAAW;AAC9B,QAAI,WAAW,CAAC,GAAG,KAAK,SAAS;AACjC,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,iBAAW,SAAS,QAAQ,CAAC,MAAM,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5D,WAAK;AAAA,IACP;AACA,SAAK,YAAY;AACjB,WAAO,KAAK,UAAU,KAAK,EAAE;AAAA,EAC/B;AAAA,EAEA,IAAI,WAAmB;AACrB,WAAO,KAAK,UAAU,KAAK,EAAE;AAAA,EAC/B;AAAA,EAEA,IAAI,aAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAkB;AACpB,WAAO,CAAC,GAAG,KAAK,MAAM;AAAA,EACxB;AAAA,EAEA,IAAI,QAA+B;AACjC,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,QAAc;AACZ,SAAK,YAAY,CAAC,GAAG,KAAK,MAAM;AAChC,SAAK,cAAc;AAAA,EACrB;AACF;;;AC9CO,SAAS,WACd,aACA,UACuB;AACvB,QAAM,MAAM,oBAAI,IAAsB;AAEtC,aAAW,OAAO,aAAa;AAC7B,UAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,QAAQ,EAAE,EAAE,MAAM,IAAI;AACxD,QAAI,CAAC,QAAQ,CAAC,OAAO;AACnB,YAAM,IAAI,MAAM,iBAAiB,GAAG,EAAE;AAAA,IACxC;AAEA,UAAM,MAAM;AACZ,UAAM,MAAM,MAAM,MAAM,EAAE;AAE1B,QAAI,UAAU;AACZ,UAAI,CAAC,SAAS,SAAS,GAAG,GAAG;AAC3B,cAAM,IAAI,MAAM,mBAAmB,GAAG,cAAc,GAAG,EAAE;AAAA,MAC3D;AACA,iBAAW,KAAK,KAAK;AACnB,YAAI,CAAC,SAAS,SAAS,CAAC,GAAG;AACzB,gBAAM,IAAI,MAAM,mBAAmB,CAAC,cAAc,GAAG,EAAE;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AAEA,QAAI,IAAI,KAAK,GAAG;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+declare class LSystem<Symbol extends string = string> {
+    private readonly _axiom;
+    private readonly _rules;
+    private _sentence;
+    private _generation;
+    constructor(_axiom: Symbol[], _rules: Map<Symbol, Symbol[]>);
+    /**
+     *
+     * @param { number } n Number of generations to generate
+     * @returns { string } The generated sentence
+     */
+    generate(n?: number): string;
+    get sentence(): string;
+    get generation(): number;
+    get axiom(): Symbol[];
+    get rules(): Map<Symbol, Symbol[]>;
+    reset(): void;
+}
+
+declare function parseRules<Symbol extends string>(definitions: string[], alphabet?: readonly Symbol[]): Map<Symbol, Symbol[]>;
+
+export { LSystem, parseRules };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+declare class LSystem<Symbol extends string = string> {
+    private readonly _axiom;
+    private readonly _rules;
+    private _sentence;
+    private _generation;
+    constructor(_axiom: Symbol[], _rules: Map<Symbol, Symbol[]>);
+    /**
+     *
+     * @param { number } n Number of generations to generate
+     * @returns { string } The generated sentence
+     */
+    generate(n?: number): string;
+    get sentence(): string;
+    get generation(): number;
+    get axiom(): Symbol[];
+    get rules(): Map<Symbol, Symbol[]>;
+    reset(): void;
+}
+
+declare function parseRules<Symbol extends string>(definitions: string[], alphabet?: readonly Symbol[]): Map<Symbol, Symbol[]>;
+
+export { LSystem, parseRules };

package/dist/index.mjs

@@ -0,0 +1,69 @@
+// src/lsystem.ts
+var LSystem = class {
+  constructor(_axiom, _rules) {
+    this._axiom = _axiom;
+    this._rules = _rules;
+    this._generation = 0;
+    this._sentence = [..._axiom];
+  }
+  /**
+   *
+   * @param { number } n Number of generations to generate
+   * @returns { string } The generated sentence
+   */
+  generate(n = 1) {
+    let sentence = [...this._sentence];
+    for (let i = 0; i < n; i++) {
+      sentence = sentence.flatMap((s) => this._rules.get(s) ?? [s]);
+      this._generation++;
+    }
+    this._sentence = sentence;
+    return this._sentence.join("");
+  }
+  get sentence() {
+    return this._sentence.join("");
+  }
+  get generation() {
+    return this._generation;
+  }
+  get axiom() {
+    return [...this._axiom];
+  }
+  get rules() {
+    return this._rules;
+  }
+  reset() {
+    this._sentence = [...this._axiom];
+    this._generation = 0;
+  }
+};
+
+// src/utils.ts
+function parseRules(definitions, alphabet) {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    const [left, right] = def.replace(/\s+/g, "").split("=>");
+    if (!left || !right) {
+      throw new Error(`Invalid rule: ${def}`);
+    }
+    const lhs = left;
+    const rhs = right.split("");
+    if (alphabet) {
+      if (!alphabet.includes(lhs)) {
+        throw new Error(`Unknown symbol "${lhs}" in rule: ${def}`);
+      }
+      for (const s of rhs) {
+        if (!alphabet.includes(s)) {
+          throw new Error(`Unknown symbol "${s}" in rule: ${def}`);
+        }
+      }
+    }
+    map.set(lhs, rhs);
+  }
+  return map;
+}
+export {
+  LSystem,
+  parseRules
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lsystem.ts","../src/utils.ts"],"sourcesContent":["export class LSystem<Symbol extends string = string> {\r\n  private _sentence: Symbol[];\r\n  private _generation: number = 0;\r\n\r\n  constructor(\r\n    private readonly _axiom: Symbol[],\r\n    private readonly _rules: Map<Symbol, Symbol[]>\r\n  ) {\r\n    this._sentence = [..._axiom];\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param { number } n Number of generations to generate\r\n   * @returns { string } The generated sentence\r\n   */\r\n  generate(n: number = 1): string {\r\n    let sentence = [...this._sentence];\r\n    for (let i = 0; i < n; i++) {\r\n      sentence = sentence.flatMap((s) => this._rules.get(s) ?? [s]);\r\n      this._generation++;\r\n    }\r\n    this._sentence = sentence;\r\n    return this._sentence.join(\"\");\r\n  }\r\n\r\n  get sentence(): string {\r\n    return this._sentence.join(\"\");\r\n  }\r\n\r\n  get generation(): number {\r\n    return this._generation;\r\n  }\r\n\r\n  get axiom(): Symbol[] {\r\n    return [...this._axiom];\r\n  }\r\n\r\n  get rules(): Map<Symbol, Symbol[]> {\r\n    return this._rules;\r\n  }\r\n\r\n  reset(): void {\r\n    this._sentence = [...this._axiom];\r\n    this._generation = 0;\r\n  }\r\n}\r\n","export function parseRules<Symbol extends string>(\r\n  definitions: string[],\r\n  alphabet?: readonly Symbol[]\r\n): Map<Symbol, Symbol[]> {\r\n  const map = new Map<Symbol, Symbol[]>();\r\n\r\n  for (const def of definitions) {\r\n    const [left, right] = def.replace(/\\s+/g, \"\").split(\"=>\");\r\n    if (!left || !right) {\r\n      throw new Error(`Invalid rule: ${def}`);\r\n    }\r\n\r\n    const lhs = left as Symbol;\r\n    const rhs = right.split(\"\") as Symbol[];\r\n\r\n    if (alphabet) {\r\n      if (!alphabet.includes(lhs)) {\r\n        throw new Error(`Unknown symbol \"${lhs}\" in rule: ${def}`);\r\n      }\r\n      for (const s of rhs) {\r\n        if (!alphabet.includes(s)) {\r\n          throw new Error(`Unknown symbol \"${s}\" in rule: ${def}`);\r\n        }\r\n      }\r\n    }\r\n\r\n    map.set(lhs, rhs);\r\n  }\r\n\r\n  return map;\r\n}\r\n"],"mappings":";AAAO,IAAM,UAAN,MAA8C;AAAA,EAInD,YACmB,QACA,QACjB;AAFiB;AACA;AAJnB,SAAQ,cAAsB;AAM5B,SAAK,YAAY,CAAC,GAAG,MAAM;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAS,IAAY,GAAW;AAC9B,QAAI,WAAW,CAAC,GAAG,KAAK,SAAS;AACjC,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,iBAAW,SAAS,QAAQ,CAAC,MAAM,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5D,WAAK;AAAA,IACP;AACA,SAAK,YAAY;AACjB,WAAO,KAAK,UAAU,KAAK,EAAE;AAAA,EAC/B;AAAA,EAEA,IAAI,WAAmB;AACrB,WAAO,KAAK,UAAU,KAAK,EAAE;AAAA,EAC/B;AAAA,EAEA,IAAI,aAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAkB;AACpB,WAAO,CAAC,GAAG,KAAK,MAAM;AAAA,EACxB;AAAA,EAEA,IAAI,QAA+B;AACjC,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,QAAc;AACZ,SAAK,YAAY,CAAC,GAAG,KAAK,MAAM;AAChC,SAAK,cAAc;AAAA,EACrB;AACF;;;AC9CO,SAAS,WACd,aACA,UACuB;AACvB,QAAM,MAAM,oBAAI,IAAsB;AAEtC,aAAW,OAAO,aAAa;AAC7B,UAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,QAAQ,EAAE,EAAE,MAAM,IAAI;AACxD,QAAI,CAAC,QAAQ,CAAC,OAAO;AACnB,YAAM,IAAI,MAAM,iBAAiB,GAAG,EAAE;AAAA,IACxC;AAEA,UAAM,MAAM;AACZ,UAAM,MAAM,MAAM,MAAM,EAAE;AAE1B,QAAI,UAAU;AACZ,UAAI,CAAC,SAAS,SAAS,GAAG,GAAG;AAC3B,cAAM,IAAI,MAAM,mBAAmB,GAAG,cAAc,GAAG,EAAE;AAAA,MAC3D;AACA,iBAAW,KAAK,KAAK;AACnB,YAAI,CAAC,SAAS,SAAS,CAAC,GAAG;AACzB,gBAAM,IAAI,MAAM,mBAAmB,CAAC,cAAc,GAAG,EAAE;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AAEA,QAAI,IAAI,KAAK,GAAG;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@rgsoft/lsystem",
+  "version": "1.0.0",
+  "description": "L-Systems library",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rgmiranda/turtle.git"
+  },
+  "keywords": [
+    "l-systems"
+  ],
+  "author": "Ricardo Miranda <rgmiranda@live.com.ar>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rgmiranda/turtle/issues"
+  },
+  "homepage": "https://github.com/rgmiranda/turtle#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "build": "tsup"
+  }
+}