@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/src/xmp/XmpMM.ts

@@ -0,0 +1,82 @@
+/**
+ * Typed accessors for the XMP Media Management schema (`xmpMM:`).
+ *
+ * @since 0.1.0
+ */
+import type * as Option from 'effect/Option';
+import * as Accessors from './internal/accessors.ts';
+import type * as Metadata from './Metadata.ts';
+import { XMP_MM } from './Namespaces.ts';
+
+/**
+ * The identifier shared by every version of the document (`xmpMM:DocumentID`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const documentId: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(
+  `${XMP_MM}DocumentID`,
+);
+
+/**
+ * Sets the identifier shared by every version of the document (`xmpMM:DocumentID`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setDocumentId: Metadata.Setter<string> = Accessors.setText(`${XMP_MM}DocumentID`);
+
+/**
+ * The identifier of this version of the document (`xmpMM:InstanceID`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const instanceId: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(
+  `${XMP_MM}InstanceID`,
+);
+
+/**
+ * Sets the identifier of this version of the document (`xmpMM:InstanceID`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setInstanceId: Metadata.Setter<string> = Accessors.setText(`${XMP_MM}InstanceID`);
+
+/**
+ * The `xmpMM:DocumentID` of the original the document was derived from (`xmpMM:OriginalDocumentID`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const originalDocumentId: (self: Metadata.Metadata) => Option.Option<string> =
+  Accessors.text(`${XMP_MM}OriginalDocumentID`);
+
+/**
+ * Sets the `xmpMM:DocumentID` of the original the document was derived from (`xmpMM:OriginalDocumentID`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setOriginalDocumentId: Metadata.Setter<string> = Accessors.setText(
+  `${XMP_MM}OriginalDocumentID`,
+);
+
+/**
+ * The document version (`xmpMM:VersionID`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const versionId: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(
+  `${XMP_MM}VersionID`,
+);
+
+/**
+ * Sets the document version (`xmpMM:VersionID`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setVersionId: Metadata.Setter<string> = Accessors.setText(`${XMP_MM}VersionID`);

package/src/xmp/XmpRights.ts

@@ -0,0 +1,83 @@
+/**
+ * Typed accessors for the XMP Rights Management schema (`xmpRights:`).
+ *
+ * @since 0.1.0
+ */
+import type * as Option from 'effect/Option';
+import * as Accessors from './internal/accessors.ts';
+import type * as Metadata from './Metadata.ts';
+import { XMP_RIGHTS } from './Namespaces.ts';
+
+/**
+ * Whether the resource is rights-managed (`xmpRights:Marked`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const marked: (self: Metadata.Metadata) => Option.Option<boolean> = Accessors.boolean(
+  `${XMP_RIGHTS}Marked`,
+);
+
+/**
+ * Sets whether the resource is rights-managed (`xmpRights:Marked`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setMarked: Metadata.Setter<boolean> = Accessors.setBoolean(`${XMP_RIGHTS}Marked`);
+
+/**
+ * The legal owners (`xmpRights:Owner`), an unordered array.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const owner: (self: Metadata.Metadata) => Option.Option<ReadonlyArray<string>> =
+  Accessors.items(`${XMP_RIGHTS}Owner`);
+
+/**
+ * Sets the legal owners (`xmpRights:Owner`), an unordered array.
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setOwner: Metadata.Setter<Iterable<string>> = Accessors.setBag(`${XMP_RIGHTS}Owner`);
+
+/**
+ * How the resource may be used (`xmpRights:UsageTerms`), a language alternative. Reads the item in `language` (default `x-default`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const usageTerms: (self: Metadata.Metadata, language?: string) => Option.Option<string> =
+  Accessors.localized(`${XMP_RIGHTS}UsageTerms`);
+
+/**
+ * Sets one language of how the resource may be used (`xmpRights:UsageTerms`), a language alternative.
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setUsageTerms: Metadata.LocalizedSetter = Accessors.setLocalized(
+  `${XMP_RIGHTS}UsageTerms`,
+);
+
+/**
+ * The URL of a rights statement (`xmpRights:WebStatement`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+export const webStatement: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(
+  `${XMP_RIGHTS}WebStatement`,
+);
+
+/**
+ * Sets the URL of a rights statement (`xmpRights:WebStatement`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+export const setWebStatement: Metadata.Setter<string> = Accessors.setText(
+  `${XMP_RIGHTS}WebStatement`,
+);

package/src/xmp/index.ts

@@ -0,0 +1,36 @@
+/**
+ * XMP (Extensible Metadata Platform, ISO 16684-1) for effect-rdf: packets,
+ * the XMP data model, typed accessors for the core, Photoshop, EXIF and TIFF schemas and extraction
+ * from JPEG and PNG files.
+ *
+ * @since 0.1.0
+ */
+
+/** @since 0.1.0 */
+export * as DublinCore from './DublinCore.ts';
+/** @since 0.1.0 */
+export * as Exif from './Exif.ts';
+/** @since 0.1.0 */
+export * as Extract from './Extract.ts';
+/** @since 0.1.0 */
+export * as Metadata from './Metadata.ts';
+/** @since 0.1.0 */
+export * as Namespaces from './Namespaces.ts';
+/** @since 0.1.0 */
+export * as Packet from './Packet.ts';
+/** @since 0.1.0 */
+export * as Pdf from './Pdf.ts';
+/** @since 0.1.0 */
+export * as PdfA from './PdfA.ts';
+/** @since 0.1.0 */
+export * as Photoshop from './Photoshop.ts';
+/** @since 0.1.0 */
+export * as Tiff from './Tiff.ts';
+/** @since 0.1.0 */
+export * as Xmp from './Xmp.ts';
+/** @since 0.1.0 */
+export * as XmpBasic from './XmpBasic.ts';
+/** @since 0.1.0 */
+export * as XmpMM from './XmpMM.ts';
+/** @since 0.1.0 */
+export * as XmpRights from './XmpRights.ts';

package/src/xmp/internal/accessors.ts

@@ -0,0 +1,72 @@
+/**
+ * Factories for the typed property accessors of the schema modules.
+ */
+import * as DateTime from 'effect/DateTime';
+import { dual } from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+import * as Metadata from '../Metadata.ts';
+
+export const text =
+  (iri: string) =>
+  (self: Metadata.Metadata): Option.Option<string> =>
+    Metadata.getText(self, iri);
+
+export const items =
+  (iri: string) =>
+  (self: Metadata.Metadata): Option.Option<ReadonlyArray<string>> =>
+    Metadata.getItems(self, iri);
+
+export const localized =
+  (iri: string) =>
+  (self: Metadata.Metadata, language?: string): Option.Option<string> =>
+    Metadata.getLocalized(self, iri, language);
+
+export const boolean =
+  (iri: string) =>
+  (self: Metadata.Metadata): Option.Option<boolean> =>
+    Option.flatMap(Metadata.getText(self, iri), (value) =>
+      value === 'True' ? Option.some(true) : value === 'False' ? Option.some(false) : Option.none(),
+    );
+
+export const dualSetter = <A>(
+  f: (self: Metadata.Metadata, value: A) => Metadata.Metadata,
+): Metadata.Setter<A> => dual(2, f);
+
+export const setter = <A>(iri: string, toValue: (value: A) => Metadata.Value): Metadata.Setter<A> =>
+  dualSetter((self: Metadata.Metadata, value: A) => Metadata.set(self, iri, toValue(value)));
+
+export const setText = (iri: string): Metadata.Setter<string> => setter(iri, Metadata.text);
+
+export const setBag = (iri: string): Metadata.Setter<Iterable<string>> => setter(iri, Metadata.bag);
+
+export const setSeq = (iri: string): Metadata.Setter<Iterable<string>> => setter(iri, Metadata.seq);
+
+export const setBoolean = (iri: string): Metadata.Setter<boolean> =>
+  setter(iri, (value: boolean) => Metadata.text(value ? 'True' : 'False'));
+
+/** XMP dates are ISO 8601 with a time-zone offset (ISO 16684-1 §8.2.1.1). */
+export const setDate = (iri: string): Metadata.Setter<DateTime.DateTime | string> =>
+  setter(iri, (value: DateTime.DateTime | string) =>
+    Metadata.text(DateTime.isDateTime(value) ? DateTime.formatIsoOffset(value) : value),
+  );
+
+const isMetadata = (u: unknown): u is Metadata.Metadata =>
+  Predicate.hasProperty(u, 'properties') && Predicate.hasProperty(u, 'about');
+
+export const setLocalized = (iri: string): Metadata.LocalizedSetter =>
+  dual(
+    (args) => isMetadata(args[0]),
+    (self: Metadata.Metadata, value: string, language?: string) =>
+      Metadata.setLocalized(self, iri, value, language),
+  );
+
+export const integer =
+  (iri: string) =>
+  (self: Metadata.Metadata): Option.Option<number> =>
+    Option.flatMap(Metadata.getText(self, iri), (value) =>
+      /^[+-]?[0-9]+$/.test(value.trim()) ? Option.some(Number(value)) : Option.none(),
+    );
+
+export const setInteger = (iri: string): Metadata.Setter<number> =>
+  setter(iri, (value: number) => Metadata.text(String(Math.trunc(value))));

package/src/xmp/internal/xml.ts

@@ -0,0 +1,63 @@
+/**
+ * The parser seam: the one module that touches an XML implementation.
+ * Everything else in this package sees only `parseRdf` (text → RDF) and the
+ * three writing helpers below, so moving from `/rdfxml`'s `Xml` parser
+ * to the effect-sax DOM replaces this file and nothing else.
+ */
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+import * as Serialization from '../../Serialization.ts';
+import * as RdfXml from '../../rdfxml/RdfXml.ts';
+import * as Xml from '../../rdfxml/Xml.ts';
+import { RDF } from '../Namespaces.ts';
+
+const isRdf = (el: Xml.Element) => el.namespace === RDF && el.localName === 'RDF';
+
+const children = (el: Xml.Element): ReadonlyArray<Xml.Element> =>
+  el.children.filter((c): c is Xml.Element => Predicate.isTagged(c, 'Element'));
+
+/**
+ * The first `rdf:RDF` element in document order. XMP puts it inside
+ * `<x:xmpmeta>` (or the older `<x:xapmeta>`), or at the root when the
+ * wrapper is omitted; SVG puts either inside `<metadata>`.
+ */
+const findRdf = (el: Xml.Element): Option.Option<Xml.Element> =>
+  isRdf(el) ? Option.some(el) : Option.firstSomeOf(children(el).map(findRdf));
+
+const FORMAT = 'XMP';
+
+const toParseError = (e: Xml.XmlParseError | Serialization.RdfParseError) =>
+  new Serialization.RdfParseError({
+    format: FORMAT,
+    message: e.message,
+    line: e.line,
+    column: e.column,
+  });
+
+/** Parses the text of an XMP packet (or a document embedding one) to RDF. */
+export const parseRdf = (
+  text: string,
+  options?: Serialization.ParseOptions,
+): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>
+  Effect.gen(function* () {
+    const doc = yield* Xml.parse(text).pipe(Effect.mapError(toParseError));
+    const root = yield* Effect.fromOption(findRdf(doc.root)).pipe(
+      Effect.mapError(
+        () =>
+          new Serialization.RdfParseError({ format: FORMAT, message: 'No rdf:RDF element found' }),
+      ),
+    );
+    return yield* RdfXml.parseDocument({ ...doc, root }, options).pipe(
+      Effect.mapError(toParseError),
+    );
+  });
+
+/** Escapes XML character data. */
+export const escapeText: (value: string) => string = Xml.escapeText;
+
+/** Escapes an XML attribute value. */
+export const escapeAttribute: (value: string) => string = Xml.escapeAttribute;
+
+/** Splits an IRI into a namespace and an `NCName` local name. */
+export const splitIri: (iri: string) => Option.Option<readonly [string, string]> = RdfXml.splitIri;