@typemf/node 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -27,6 +27,7 @@ module.exports = __toCommonJS(index_exports);
 // src/node-file-uri-converter.ts
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
+var import_node_url = require("url");
 var NodeFileUriConverter = class {
   canHandle(uri) {
     return uri.getScheme() === "file";
@@ -49,11 +50,21 @@ var NodeFileUriConverter = class {
       return false;
     }
   }
+  /**
+   * A URI's own `getPath()` is unusable directly as a filesystem path on every
+   * platform/caller combination - a URI built from a Windows `fsPath` ("c:\Users\...") has a
+   * `path` of "/c:\Users\..." (createFileURI only ever prepends "/"; it doesn't know about drive
+   * letters or backslashes), and a URI parsed from real "file:" text keeps its percent-encoding
+   * ("a%20b") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform
+   * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL
+   * parser does this for every "special" scheme, "file" included) and decodes percent-escapes -
+   * so this converts through it instead of reading `getPath()` by hand.
+   */
   pathFor(uri) {
     if (uri.getScheme() !== "file") {
       throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);
     }
-    return uri.trimFragment().getPath();
+    return (0, import_node_url.fileURLToPath)(uri.trimFragment().toString());
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/node-file-uri-converter.ts"],"sourcesContent":["export * from './node-file-uri-converter.js';\n","import { URI, UriConverter } from '@typemf/core';\nimport { access, mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\n\n/**\n * The Node-only, fs-backed UriConverter discussed back when @typemf/core's\n * resource/ layer was designed: it exists as its own package specifically\n * so that nothing shipping to a browser bundle ever pulls in Node's `fs`\n * module, and so a consumer wanting only the in-memory or a fetch()-based\n * converter never needs this one at all.\n *\n * Handles the \"file\" URI scheme only. Register it into a ResourceSet's\n * UriConverterRegistry alongside any other converter for other schemes -\n * see the \"browser could load an https:// XMI file without fs access\"\n * discussion for why this is a registry rather than a single slot.\n */\nexport class NodeFileUriConverter implements UriConverter {\n  canHandle(uri: URI): boolean {\n    return uri.getScheme() === 'file';\n  }\n\n  async readBinary(uri: URI): Promise<Uint8Array> {\n    const path = this.pathFor(uri);\n    const buffer = await readFile(path);\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  }\n\n  async writeBinary(uri: URI, content: Uint8Array): Promise<void> {\n    const path = this.pathFor(uri);\n    await mkdir(dirname(path), { recursive: true });\n    await writeFile(path, content);\n  }\n\n  async exists(uri: URI): Promise<boolean> {\n    try {\n      await access(this.pathFor(uri));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private pathFor(uri: URI): string {\n    if (uri.getScheme() !== 'file') {\n      throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);\n    }\n    return uri.trimFragment().getPath();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,sBAAmD;AACnD,uBAAwB;AAcjB,IAAM,uBAAN,MAAmD;AAAA,EACxD,UAAU,KAAmB;AAC3B,WAAO,IAAI,UAAU,MAAM;AAAA,EAC7B;AAAA,EAEA,MAAM,WAAW,KAA+B;AAC9C,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,SAAS,UAAM,0BAAS,IAAI;AAClC,WAAO,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,EAC3E;AAAA,EAEA,MAAM,YAAY,KAAU,SAAoC;AAC9D,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,cAAM,2BAAM,0BAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AAC9C,cAAM,2BAAU,MAAM,OAAO;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,QAAI;AACF,gBAAM,wBAAO,KAAK,QAAQ,GAAG,CAAC;AAC9B,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEQ,QAAQ,KAAkB;AAChC,QAAI,IAAI,UAAU,MAAM,QAAQ;AAC9B,YAAM,IAAI,MAAM,8CAA8C,IAAI,UAAU,CAAC,kBAAkB;AAAA,IACjG;AACA,WAAO,IAAI,aAAa,EAAE,QAAQ;AAAA,EACpC;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/node-file-uri-converter.ts"],"sourcesContent":["export * from './node-file-uri-converter.js';\n","import { URI, UriConverter } from '@typemf/core';\nimport { access, mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\n/**\n * The Node-only, fs-backed UriConverter discussed back when @typemf/core's\n * resource/ layer was designed: it exists as its own package specifically\n * so that nothing shipping to a browser bundle ever pulls in Node's `fs`\n * module, and so a consumer wanting only the in-memory or a fetch()-based\n * converter never needs this one at all.\n *\n * Handles the \"file\" URI scheme only. Register it into a ResourceSet's\n * UriConverterRegistry alongside any other converter for other schemes -\n * see the \"browser could load an https:// XMI file without fs access\"\n * discussion for why this is a registry rather than a single slot.\n */\nexport class NodeFileUriConverter implements UriConverter {\n  canHandle(uri: URI): boolean {\n    return uri.getScheme() === 'file';\n  }\n\n  async readBinary(uri: URI): Promise<Uint8Array> {\n    const path = this.pathFor(uri);\n    const buffer = await readFile(path);\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  }\n\n  async writeBinary(uri: URI, content: Uint8Array): Promise<void> {\n    const path = this.pathFor(uri);\n    await mkdir(dirname(path), { recursive: true });\n    await writeFile(path, content);\n  }\n\n  async exists(uri: URI): Promise<boolean> {\n    try {\n      await access(this.pathFor(uri));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * A URI's own `getPath()` is unusable directly as a filesystem path on every\n   * platform/caller combination - a URI built from a Windows `fsPath` (\"c:\\Users\\...\") has a\n   * `path` of \"/c:\\Users\\...\" (createFileURI only ever prepends \"/\"; it doesn't know about drive\n   * letters or backslashes), and a URI parsed from real \"file:\" text keeps its percent-encoding\n   * (\"a%20b\") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform\n   * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL\n   * parser does this for every \"special\" scheme, \"file\" included) and decodes percent-escapes -\n   * so this converts through it instead of reading `getPath()` by hand.\n   */\n  private pathFor(uri: URI): string {\n    if (uri.getScheme() !== 'file') {\n      throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);\n    }\n    return fileURLToPath(uri.trimFragment().toString());\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,sBAAmD;AACnD,uBAAwB;AACxB,sBAA8B;AAcvB,IAAM,uBAAN,MAAmD;AAAA,EACxD,UAAU,KAAmB;AAC3B,WAAO,IAAI,UAAU,MAAM;AAAA,EAC7B;AAAA,EAEA,MAAM,WAAW,KAA+B;AAC9C,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,SAAS,UAAM,0BAAS,IAAI;AAClC,WAAO,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,EAC3E;AAAA,EAEA,MAAM,YAAY,KAAU,SAAoC;AAC9D,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,cAAM,2BAAM,0BAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AAC9C,cAAM,2BAAU,MAAM,OAAO;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,QAAI;AACF,gBAAM,wBAAO,KAAK,QAAQ,GAAG,CAAC;AAC9B,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYQ,QAAQ,KAAkB;AAChC,QAAI,IAAI,UAAU,MAAM,QAAQ;AAC9B,YAAM,IAAI,MAAM,8CAA8C,IAAI,UAAU,CAAC,kBAAkB;AAAA,IACjG;AACA,eAAO,+BAAc,IAAI,aAAa,EAAE,SAAS,CAAC;AAAA,EACpD;AACF;","names":[]}

package/dist/index.d.cts

@@ -17,6 +17,16 @@ declare class NodeFileUriConverter implements UriConverter {
     readBinary(uri: URI): Promise<Uint8Array>;
     writeBinary(uri: URI, content: Uint8Array): Promise<void>;
     exists(uri: URI): Promise<boolean>;
+    /**
+     * A URI's own `getPath()` is unusable directly as a filesystem path on every
+     * platform/caller combination - a URI built from a Windows `fsPath` ("c:\Users\...") has a
+     * `path` of "/c:\Users\..." (createFileURI only ever prepends "/"; it doesn't know about drive
+     * letters or backslashes), and a URI parsed from real "file:" text keeps its percent-encoding
+     * ("a%20b") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform
+     * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL
+     * parser does this for every "special" scheme, "file" included) and decodes percent-escapes -
+     * so this converts through it instead of reading `getPath()` by hand.
+     */
     private pathFor;
 }
 

package/dist/index.d.ts

@@ -17,6 +17,16 @@ declare class NodeFileUriConverter implements UriConverter {
     readBinary(uri: URI): Promise<Uint8Array>;
     writeBinary(uri: URI, content: Uint8Array): Promise<void>;
     exists(uri: URI): Promise<boolean>;
+    /**
+     * A URI's own `getPath()` is unusable directly as a filesystem path on every
+     * platform/caller combination - a URI built from a Windows `fsPath` ("c:\Users\...") has a
+     * `path` of "/c:\Users\..." (createFileURI only ever prepends "/"; it doesn't know about drive
+     * letters or backslashes), and a URI parsed from real "file:" text keeps its percent-encoding
+     * ("a%20b") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform
+     * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL
+     * parser does this for every "special" scheme, "file" included) and decodes percent-escapes -
+     * so this converts through it instead of reading `getPath()` by hand.
+     */
     private pathFor;
 }
 

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/node-file-uri-converter.ts
 import { access, mkdir, readFile, writeFile } from "fs/promises";
 import { dirname } from "path";
+import { fileURLToPath } from "url";
 var NodeFileUriConverter = class {
   canHandle(uri) {
     return uri.getScheme() === "file";
@@ -23,11 +24,21 @@ var NodeFileUriConverter = class {
       return false;
     }
   }
+  /**
+   * A URI's own `getPath()` is unusable directly as a filesystem path on every
+   * platform/caller combination - a URI built from a Windows `fsPath` ("c:\Users\...") has a
+   * `path` of "/c:\Users\..." (createFileURI only ever prepends "/"; it doesn't know about drive
+   * letters or backslashes), and a URI parsed from real "file:" text keeps its percent-encoding
+   * ("a%20b") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform
+   * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL
+   * parser does this for every "special" scheme, "file" included) and decodes percent-escapes -
+   * so this converts through it instead of reading `getPath()` by hand.
+   */
   pathFor(uri) {
     if (uri.getScheme() !== "file") {
       throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);
     }
-    return uri.trimFragment().getPath();
+    return fileURLToPath(uri.trimFragment().toString());
   }
 };
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/node-file-uri-converter.ts"],"sourcesContent":["import { URI, UriConverter } from '@typemf/core';\nimport { access, mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\n\n/**\n * The Node-only, fs-backed UriConverter discussed back when @typemf/core's\n * resource/ layer was designed: it exists as its own package specifically\n * so that nothing shipping to a browser bundle ever pulls in Node's `fs`\n * module, and so a consumer wanting only the in-memory or a fetch()-based\n * converter never needs this one at all.\n *\n * Handles the \"file\" URI scheme only. Register it into a ResourceSet's\n * UriConverterRegistry alongside any other converter for other schemes -\n * see the \"browser could load an https:// XMI file without fs access\"\n * discussion for why this is a registry rather than a single slot.\n */\nexport class NodeFileUriConverter implements UriConverter {\n  canHandle(uri: URI): boolean {\n    return uri.getScheme() === 'file';\n  }\n\n  async readBinary(uri: URI): Promise<Uint8Array> {\n    const path = this.pathFor(uri);\n    const buffer = await readFile(path);\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  }\n\n  async writeBinary(uri: URI, content: Uint8Array): Promise<void> {\n    const path = this.pathFor(uri);\n    await mkdir(dirname(path), { recursive: true });\n    await writeFile(path, content);\n  }\n\n  async exists(uri: URI): Promise<boolean> {\n    try {\n      await access(this.pathFor(uri));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private pathFor(uri: URI): string {\n    if (uri.getScheme() !== 'file') {\n      throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);\n    }\n    return uri.trimFragment().getPath();\n  }\n}\n"],"mappings":";AACA,SAAS,QAAQ,OAAO,UAAU,iBAAiB;AACnD,SAAS,eAAe;AAcjB,IAAM,uBAAN,MAAmD;AAAA,EACxD,UAAU,KAAmB;AAC3B,WAAO,IAAI,UAAU,MAAM;AAAA,EAC7B;AAAA,EAEA,MAAM,WAAW,KAA+B;AAC9C,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,SAAS,MAAM,SAAS,IAAI;AAClC,WAAO,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,EAC3E;AAAA,EAEA,MAAM,YAAY,KAAU,SAAoC;AAC9D,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,MAAM,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AAC9C,UAAM,UAAU,MAAM,OAAO;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,QAAI;AACF,YAAM,OAAO,KAAK,QAAQ,GAAG,CAAC;AAC9B,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEQ,QAAQ,KAAkB;AAChC,QAAI,IAAI,UAAU,MAAM,QAAQ;AAC9B,YAAM,IAAI,MAAM,8CAA8C,IAAI,UAAU,CAAC,kBAAkB;AAAA,IACjG;AACA,WAAO,IAAI,aAAa,EAAE,QAAQ;AAAA,EACpC;AACF;","names":[]}
+{"version":3,"sources":["../src/node-file-uri-converter.ts"],"sourcesContent":["import { URI, UriConverter } from '@typemf/core';\nimport { access, mkdir, readFile, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\n/**\n * The Node-only, fs-backed UriConverter discussed back when @typemf/core's\n * resource/ layer was designed: it exists as its own package specifically\n * so that nothing shipping to a browser bundle ever pulls in Node's `fs`\n * module, and so a consumer wanting only the in-memory or a fetch()-based\n * converter never needs this one at all.\n *\n * Handles the \"file\" URI scheme only. Register it into a ResourceSet's\n * UriConverterRegistry alongside any other converter for other schemes -\n * see the \"browser could load an https:// XMI file without fs access\"\n * discussion for why this is a registry rather than a single slot.\n */\nexport class NodeFileUriConverter implements UriConverter {\n  canHandle(uri: URI): boolean {\n    return uri.getScheme() === 'file';\n  }\n\n  async readBinary(uri: URI): Promise<Uint8Array> {\n    const path = this.pathFor(uri);\n    const buffer = await readFile(path);\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  }\n\n  async writeBinary(uri: URI, content: Uint8Array): Promise<void> {\n    const path = this.pathFor(uri);\n    await mkdir(dirname(path), { recursive: true });\n    await writeFile(path, content);\n  }\n\n  async exists(uri: URI): Promise<boolean> {\n    try {\n      await access(this.pathFor(uri));\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * A URI's own `getPath()` is unusable directly as a filesystem path on every\n   * platform/caller combination - a URI built from a Windows `fsPath` (\"c:\\Users\\...\") has a\n   * `path` of \"/c:\\Users\\...\" (createFileURI only ever prepends \"/\"; it doesn't know about drive\n   * letters or backslashes), and a URI parsed from real \"file:\" text keeps its percent-encoding\n   * (\"a%20b\") rather than decoding it. `fileURLToPath` is Node's own, already-correct, per-platform\n   * answer to exactly this problem - it treats backslashes as path separators (the WHATWG URL\n   * parser does this for every \"special\" scheme, \"file\" included) and decodes percent-escapes -\n   * so this converts through it instead of reading `getPath()` by hand.\n   */\n  private pathFor(uri: URI): string {\n    if (uri.getScheme() !== 'file') {\n      throw new Error(`NodeFileUriConverter cannot handle scheme '${uri.getScheme()}' (only 'file').`);\n    }\n    return fileURLToPath(uri.trimFragment().toString());\n  }\n}\n"],"mappings":";AACA,SAAS,QAAQ,OAAO,UAAU,iBAAiB;AACnD,SAAS,eAAe;AACxB,SAAS,qBAAqB;AAcvB,IAAM,uBAAN,MAAmD;AAAA,EACxD,UAAU,KAAmB;AAC3B,WAAO,IAAI,UAAU,MAAM;AAAA,EAC7B;AAAA,EAEA,MAAM,WAAW,KAA+B;AAC9C,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,SAAS,MAAM,SAAS,IAAI;AAClC,WAAO,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,EAC3E;AAAA,EAEA,MAAM,YAAY,KAAU,SAAoC;AAC9D,UAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,UAAM,MAAM,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AAC9C,UAAM,UAAU,MAAM,OAAO;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,QAAI;AACF,YAAM,OAAO,KAAK,QAAQ,GAAG,CAAC;AAC9B,aAAO;AAAA,IACT,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYQ,QAAQ,KAAkB;AAChC,QAAI,IAAI,UAAU,MAAM,QAAQ;AAC9B,YAAM,IAAI,MAAM,8CAA8C,IAAI,UAAU,CAAC,kBAAkB;AAAA,IACjG;AACA,WAAO,cAAc,IAAI,aAAa,EAAE,SAAS,CAAC;AAAA,EACpD;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typemf/node",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -27,12 +27,12 @@
     "provenance": true
   },
   "devDependencies": {
-    "@typemf/core": "0.6.0",
-    "@typemf/json": "0.6.0",
-    "@typemf/xmi": "0.6.0"
+    "@typemf/core": "0.8.0",
+    "@typemf/json": "0.8.0",
+    "@typemf/xmi": "0.8.0"
   },
   "peerDependencies": {
-    "@typemf/core": "^0.6.0"
+    "@typemf/core": "^0.8.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json --noEmit && tsup",