uniword 1.2.5 → 1.3.0

data/lib/uniword/ooxml/part_definition.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    # Declarative description of one OOXML package part kind.
+    #
+    # A PartDefinition is the single source of truth for a part's
+    # package path, content type, relationship type, and the form its
+    # [Content_Types].xml entry takes (Default by extension or Override
+    # by part name). Instances are immutable value objects registered
+    # in {PartRegistry}; consumers derive every literal from them.
+    #
+    # Parts with instance-numbered paths (headers, footers, charts,
+    # customXml items) carry a +path_pattern+/+target_pattern+ with
+    # +format+-style placeholders (e.g. "word/header%<counter>d.xml")
+    # instead of a fixed path.
+    #
+    # @example Fixed part
+    #   PartDefinition.new(
+    #     key: :styles, path: "word/styles.xml", target: "styles.xml",
+    #     content_type: "...styles+xml",
+    #     rel_type: ".../relationships/styles",
+    #     required: true, kind: :override, rels_scope: :document,
+    #   )
+    class PartDefinition
+      # @return [Symbol] unique registry key (e.g. :styles)
+      attr_reader :key
+
+      # @return [String, nil] package-relative path ("word/styles.xml")
+      attr_reader :path
+
+      # @return [String, nil] path template for instance-numbered parts
+      attr_reader :path_pattern
+
+      # @return [String, nil] relationship Target as written in .rels
+      #   (relative to the owning part; defaults to +path+)
+      attr_reader :target
+
+      # @return [String, nil] Target template for numbered parts
+      attr_reader :target_pattern
+
+      # @return [String, nil] MIME content type (nil when dynamic,
+      #   e.g. images whose type depends on the file extension)
+      attr_reader :content_type
+
+      # @return [String, nil] relationship type URI (nil when the part
+      #   is not referenced by a relationship)
+      attr_reader :rel_type
+
+      # @return [String, nil] file extension for Default entries
+      attr_reader :extension
+
+      # @return [Boolean] whether a minimal valid package carries it
+      attr_reader :required
+
+      # @return [Symbol] :override, :default, or :none (no
+      #   [Content_Types].xml entry of its own)
+      attr_reader :kind
+
+      # @return [Symbol, nil] :package or :document — which .rels part
+      #   the relationship lives in (nil when +rel_type+ is nil)
+      attr_reader :rels_scope
+
+      # @return [Boolean] whether ContentTypes.generate includes it in
+      #   the comprehensive [Content_Types].xml for new DOCX packages
+      attr_reader :standard
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(key:, kind:, path: nil, path_pattern: nil,
+                     target: nil, target_pattern: nil,
+                     content_type: nil, rel_type: nil, extension: nil,
+                     required: false, rels_scope: nil, standard: false)
+        @key = key.to_sym
+        @kind = kind
+        @path = path
+        @path_pattern = path_pattern
+        @target = target || path
+        @target_pattern = target_pattern
+        @content_type = content_type
+        @rel_type = rel_type
+        @extension = extension
+        @required = required
+        @rels_scope = rels_scope
+        @standard = standard
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # @return [Boolean] true for [Content_Types].xml Override entries
+      def override?
+        kind == :override
+      end
+
+      # @return [Boolean] true for [Content_Types].xml Default entries
+      def default?
+        kind == :default
+      end
+
+      # @return [Boolean] true when a minimal valid package carries it
+      def required?
+        !!required
+      end
+
+      # @return [Boolean] true when ContentTypes.generate includes it
+      def standard?
+        !!standard
+      end
+
+      # @return [Boolean] true when the relationship lives in _rels/.rels
+      def package_rel?
+        rels_scope == :package
+      end
+
+      # Resolve the package-relative path, interpolating pattern
+      # placeholders for instance-numbered parts.
+      #
+      # @param vars [Hash] placeholder values (e.g. counter: 1)
+      # @return [String, nil] e.g. "word/header1.xml"
+      def path_for(**vars)
+        expand(path_pattern || path, vars)
+      end
+
+      # Resolve the content-type Override part name (leading slash).
+      #
+      # @param vars [Hash] placeholder values for numbered parts
+      # @return [String, nil] e.g. "/word/header1.xml"
+      def part_name_for(**vars)
+        resolved = path_for(**vars)
+        resolved && "/#{resolved}"
+      end
+
+      # Resolve the relationship Target attribute.
+      #
+      # @param vars [Hash] placeholder values for numbered parts
+      # @return [String, nil] e.g. "header1.xml"
+      def target_for(**vars)
+        expand(target_pattern || target, vars)
+      end
+
+      # Fixed-path Override part name (leading slash).
+      #
+      # @return [String, nil] e.g. "/word/styles.xml"
+      def part_name
+        path && "/#{path}"
+      end
+
+      # Two definitions are equal when every field matches.
+      def ==(other)
+        other.is_a?(PartDefinition) && fields == other.fields
+      end
+
+      protected
+
+      # @return [Array] field values in declaration order, used for
+      #   value equality
+      def fields
+        [key, kind, path, path_pattern, target, target_pattern,
+         content_type, rel_type, extension, required, rels_scope,
+         standard]
+      end
+
+      private
+
+      def expand(template, vars)
+        return nil unless template
+        return template if vars.empty?
+
+        format(template, vars)
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/part_registry.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    # Single source of truth for OOXML package part metadata.
+    #
+    # Maps every part kind the library writes to its package path,
+    # content type, relationship type, and [Content_Types].xml entry
+    # form (Default vs Override). Content type and relationship type
+    # literals live ONLY here; consumers (Uniword::ContentTypes,
+    # Docx::PackageDefaults, Docx::Reconciler::PackageStructure, and
+    # the Docx::PackageSerialization inject_* methods) derive from
+    # this registry instead of holding their own literals.
+    #
+    # Open/closed: a new part kind is added by registering a
+    # PartDefinition — consumers need no further changes.
+    #
+    # @example Look up a part by key
+    #   defn = PartRegistry.find_by_key(:styles)
+    #   defn.part_name # => "/word/styles.xml"
+    #   defn.rel_type  # => ".../relationships/styles"
+    #
+    # @example Register a custom part kind
+    #   PartRegistry.register(
+    #     PartDefinition.new(key: :glossary, path: "word/glossary/document.xml",
+    #                        target: "glossary/document.xml",
+    #                        content_type: "...document.glossary+xml",
+    #                        rel_type: ".../glossaryDocument",
+    #                        kind: :override, rels_scope: :document)
+    #   )
+    module PartRegistry
+      # Relationship type base URIs. These literals appear only here.
+      OFFICE_REL_BASE =
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+      PACKAGE_REL_BASE =
+        "http://schemas.openxmlformats.org/package/2006/relationships"
+
+      # Content type prefixes (literals appear only here).
+      CT_OFFICE = "application/vnd.openxmlformats-officedocument"
+      CT_WML = "#{CT_OFFICE}.wordprocessingml".freeze
+      CT_PACKAGE = "application/vnd.openxmlformats-package"
+
+      # Built-in registrations. Registration order is observable in
+      # emitted output: the :standard entries reproduce the historic
+      # ContentTypes.generate ordering exactly (defaults first —
+      # jpeg, png, gif, rels, xml — then overrides in the historic
+      # order). Non-standard parts follow; consumers select their own
+      # ordered subsets by key.
+      BUILT_INS = [
+        # -- Content-type Defaults (extension → content type) --
+        { key: :jpeg, kind: :default, extension: "jpeg",
+          content_type: "image/jpeg", standard: true },
+        { key: :png, kind: :default, extension: "png",
+          content_type: "image/png", standard: true },
+        { key: :gif, kind: :default, extension: "gif",
+          content_type: "image/gif", standard: true },
+        { key: :rels, kind: :default, extension: "rels",
+          content_type: "#{CT_PACKAGE}.relationships+xml",
+          required: true, standard: true },
+        { key: :xml, kind: :default, extension: "xml",
+          content_type: "application/xml",
+          required: true, standard: true },
+
+        # -- Standard Override parts (historic generate order) --
+        { key: :document, kind: :override, path: "word/document.xml",
+          content_type: "#{CT_WML}.document.main+xml",
+          rel_type: "#{OFFICE_REL_BASE}/officeDocument",
+          required: true, standard: true, rels_scope: :package },
+        { key: :numbering, kind: :override, path: "word/numbering.xml",
+          target: "numbering.xml", content_type: "#{CT_WML}.numbering+xml",
+          rel_type: "#{OFFICE_REL_BASE}/numbering",
+          standard: true, rels_scope: :document },
+        { key: :styles, kind: :override, path: "word/styles.xml",
+          target: "styles.xml", content_type: "#{CT_WML}.styles+xml",
+          rel_type: "#{OFFICE_REL_BASE}/styles",
+          required: true, standard: true, rels_scope: :document },
+        { key: :settings, kind: :override, path: "word/settings.xml",
+          target: "settings.xml", content_type: "#{CT_WML}.settings+xml",
+          rel_type: "#{OFFICE_REL_BASE}/settings",
+          required: true, standard: true, rels_scope: :document },
+        { key: :web_settings, kind: :override, path: "word/webSettings.xml",
+          target: "webSettings.xml",
+          content_type: "#{CT_WML}.webSettings+xml",
+          rel_type: "#{OFFICE_REL_BASE}/webSettings",
+          required: true, standard: true, rels_scope: :document },
+        { key: :font_table, kind: :override, path: "word/fontTable.xml",
+          target: "fontTable.xml",
+          content_type: "#{CT_WML}.fontTable+xml",
+          rel_type: "#{OFFICE_REL_BASE}/fontTable",
+          required: true, standard: true, rels_scope: :document },
+        { key: :theme, kind: :override, path: "word/theme/theme1.xml",
+          target: "theme/theme1.xml",
+          content_type: "#{CT_OFFICE}.theme+xml",
+          rel_type: "#{OFFICE_REL_BASE}/theme",
+          standard: true, rels_scope: :document },
+        { key: :core_properties, kind: :override, path: "docProps/core.xml",
+          content_type: "#{CT_PACKAGE}.core-properties+xml",
+          rel_type: "#{PACKAGE_REL_BASE}/metadata/core-properties",
+          required: true, standard: true, rels_scope: :package },
+        { key: :app_properties, kind: :override, path: "docProps/app.xml",
+          content_type: "#{CT_OFFICE}.extended-properties+xml",
+          rel_type: "#{OFFICE_REL_BASE}/extended-properties",
+          required: true, standard: true, rels_scope: :package },
+
+        # -- Optional document parts --
+        { key: :footnotes, kind: :override, path: "word/footnotes.xml",
+          target: "footnotes.xml",
+          content_type: "#{CT_WML}.footnotes+xml",
+          rel_type: "#{OFFICE_REL_BASE}/footnotes",
+          rels_scope: :document },
+        { key: :endnotes, kind: :override, path: "word/endnotes.xml",
+          target: "endnotes.xml",
+          content_type: "#{CT_WML}.endnotes+xml",
+          rel_type: "#{OFFICE_REL_BASE}/endnotes",
+          rels_scope: :document },
+        { key: :comments, kind: :override, path: "word/comments.xml",
+          target: "comments.xml",
+          content_type: "#{CT_WML}.comments+xml",
+          rel_type: "#{OFFICE_REL_BASE}/comments",
+          rels_scope: :document },
+        { key: :bibliography, kind: :override, path: "word/sources.xml",
+          target: "sources.xml",
+          content_type: "#{CT_OFFICE}.bibliography+xml",
+          rel_type: "#{OFFICE_REL_BASE}/bibliography",
+          rels_scope: :document },
+        { key: :header, kind: :override,
+          path_pattern: "word/header%<counter>d.xml",
+          target_pattern: "header%<counter>d.xml",
+          content_type: "#{CT_WML}.header+xml",
+          rel_type: "#{OFFICE_REL_BASE}/header",
+          rels_scope: :document },
+        { key: :footer, kind: :override,
+          path_pattern: "word/footer%<counter>d.xml",
+          target_pattern: "footer%<counter>d.xml",
+          content_type: "#{CT_WML}.footer+xml",
+          rel_type: "#{OFFICE_REL_BASE}/footer",
+          rels_scope: :document },
+        { key: :custom_properties, kind: :override,
+          path: "docProps/custom.xml",
+          content_type: "#{CT_OFFICE}.custom-properties+xml",
+          rel_type: "#{OFFICE_REL_BASE}/custom-properties",
+          rels_scope: :package },
+        { key: :chart, kind: :override,
+          path_pattern: "word/charts/chart%<n>d.xml",
+          target_pattern: "charts/chart%<n>d.xml",
+          content_type: "#{CT_OFFICE}.drawingml.chart+xml",
+          rel_type: "#{OFFICE_REL_BASE}/chart",
+          rels_scope: :document },
+        # Images carry a per-extension Default content type resolved
+        # from the image data at save time, so content_type is nil.
+        { key: :image, kind: :default,
+          path_pattern: "word/media/%<name>s",
+          target_pattern: "media/%<name>s",
+          rel_type: "#{OFFICE_REL_BASE}/image",
+          rels_scope: :document },
+        { key: :ole_object, kind: :override,
+          path_pattern: "word/embeddings/%<name>s",
+          target_pattern: "embeddings/%<name>s",
+          content_type: "#{CT_OFFICE}.oleObject",
+          rel_type: "#{OFFICE_REL_BASE}/oleObject",
+          rels_scope: :document },
+        # customXml items themselves fall under the "xml" Default;
+        # only their itemProps parts get an Override.
+        { key: :custom_xml_item, kind: :none,
+          path_pattern: "customXml/item%<index>d.xml" },
+        { key: :custom_xml_item_props, kind: :override,
+          path_pattern: "customXml/itemProps%<index>d.xml",
+          content_type: "#{CT_OFFICE}.customXmlProperties+xml" },
+        # Hyperlink relationships target external URLs; no part, no
+        # content type.
+        { key: :hyperlink, kind: :none,
+          rel_type: "#{OFFICE_REL_BASE}/hyperlink",
+          rels_scope: :document },
+        # Theme part of THMX (theme) packages, rooted at /theme.
+        { key: :thmx_theme, kind: :override, path: "theme/theme1.xml",
+          content_type: "#{CT_OFFICE}.theme+xml", required: true },
+      ].freeze
+
+      class << self
+        # Register a part definition. Re-registering an existing key
+        # replaces it in place (preserving position); new keys append.
+        #
+        # @param definition [PartDefinition] definition to register
+        # @return [PartDefinition] the registered definition
+        # @raise [ArgumentError] when not given a PartDefinition
+        def register(definition)
+          unless definition.is_a?(PartDefinition)
+            raise ArgumentError,
+                  "expected PartDefinition, got #{definition.class}"
+          end
+
+          index = definitions.index { |d| d.key == definition.key }
+          if index
+            definitions[index] = definition
+          else
+            definitions << definition
+          end
+          definition
+        end
+
+        # Remove a registered definition (primarily for tests).
+        #
+        # @param key [Symbol] registry key
+        # @return [Array<PartDefinition>, nil] the definitions list if
+        #   a definition was removed, nil when the key was absent
+        def unregister(key)
+          definitions.reject! { |d| d.key == key.to_sym }
+        end
+
+        # @return [Array<PartDefinition>] all definitions, in
+        #   registration order (a copy; safe to mutate)
+        def all
+          definitions.dup
+        end
+
+        # @param key [Symbol] registry key (e.g. :styles)
+        # @return [PartDefinition, nil]
+        def find_by_key(key)
+          definitions.find { |d| d.key == key.to_sym }
+        end
+
+        # Find by package path; accepts both "word/styles.xml" and
+        # "/word/styles.xml" forms, and matches numbered paths against
+        # registered patterns ("word/header2.xml" → :header).
+        #
+        # @param path [String] package-relative path
+        # @return [PartDefinition, nil]
+        def find_by_path(path)
+          normalized = path.to_s.delete_prefix("/")
+          definitions.find { |d| path_match?(d, normalized) }
+        end
+
+        # @param content_type [String] MIME content type
+        # @return [PartDefinition, nil] first definition with this type
+        def find_by_content_type(content_type)
+          definitions.find { |d| d.content_type == content_type }
+        end
+
+        # Find an Override definition by content-type part name.
+        #
+        # @param part_name [String] e.g. "/word/styles.xml"
+        # @return [PartDefinition, nil]
+        def override_for(part_name)
+          normalized = part_name.to_s.delete_prefix("/")
+          definitions.find do |d|
+            d.override? && path_match?(d, normalized)
+          end
+        end
+
+        # Find a Default definition by file extension.
+        #
+        # @param extension [String] e.g. "png"
+        # @return [PartDefinition, nil]
+        def default_for(extension)
+          definitions.find do |d|
+            d.default? && d.extension == extension.to_s
+          end
+        end
+
+        # Definitions included in the comprehensive [Content_Types].xml
+        # that ContentTypes.generate emits for new DOCX packages.
+        #
+        # @return [Array<PartDefinition>] in registration order
+        def standard_defaults
+          definitions.select { |d| d.standard? && d.default? }
+        end
+
+        # @return [Array<PartDefinition>] in registration order
+        def standard_overrides
+          definitions.select { |d| d.standard? && d.override? }
+        end
+
+        # Relationship type URIs whose relationships belong in the
+        # package-level _rels/.rels part.
+        #
+        # @return [Array<String>] in registration order
+        def package_rel_types
+          definitions.filter_map { |d| d.rel_type if d.package_rel? }
+        end
+
+        private
+
+        def definitions
+          @definitions ||= []
+        end
+
+        def path_match?(definition, normalized_path)
+          return true if definition.path == normalized_path
+
+          pattern = definition.path_pattern
+          !pattern.nil? && normalized_path.match?(template_regex(pattern))
+        end
+
+        # Convert a pattern like "word/header%<counter>d.xml" into a
+        # matching regexp: %<name>d → digits, %<name>s → any path run.
+        def template_regex(template)
+          source = template.split(/(%<\w+>[ds])/).map do |part|
+            case part
+            when /%<\w+>d/ then "\\d+"
+            when /%<\w+>s/ then ".+?"
+            else Regexp.escape(part)
+            end
+          end.join
+          /\A#{source}\z/
+        end
+      end
+
+      BUILT_INS.each { |attrs| register(PartDefinition.new(**attrs)) }
+    end
+  end
+end

data/lib/uniword/ooxml/relationships/image_relationship.rb

@@ -12,7 +12,7 @@ module Uniword
         def initialize(target:)
           super(
             id: "rId#{SecureRandom.hex(4)}",
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+            type: PartRegistry.find_by_key(:image).rel_type,
             target: target
           )
         end

data/lib/uniword/ooxml/relationships/package_relationships.rb

@@ -23,35 +23,33 @@ module Uniword
         #
         # Generate package-level .rels file
         #
+        # Historical rId assignment: rId3 = app, rId2 = core,
+        # rId1 = document (kept for byte-identical DOTX output).
+        #
         # @return [PackageRelationships] Relationships object for _rels/.rels
-        def self.next_available_rid(relationships)
-          max = relationships.relationships.filter_map do |r|
-            r.id[/\ArId(\d+)\z/, 1]&.to_i
-          end.max || 0
-          "rId#{max + 1}"
-        end
-
         def self.generate_package_rels
           new(
             relationships: [
-              PackageRelationship.new(
-                id: "rId3",
-                type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
-                target: "docProps/app.xml",
-              ),
-              PackageRelationship.new(
-                id: "rId2",
-                type: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
-                target: "docProps/core.xml",
-              ),
-              PackageRelationship.new(
-                id: "rId1",
-                type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
-                target: "word/document.xml",
-              ),
+              package_relationship("rId3", :app_properties),
+              package_relationship("rId2", :core_properties),
+              package_relationship("rId1", :document),
             ],
           )
         end
+
+        # Build one package-level relationship from the registry.
+        #
+        # @param rid [String] relationship ID
+        # @param key [Symbol] PartRegistry key
+        # @return [PackageRelationship]
+        def self.package_relationship(rid, key)
+          definition = PartRegistry.find_by_key(key)
+          PackageRelationship.new(
+            id: rid,
+            type: definition.rel_type,
+            target: definition.target,
+          )
+        end
       end
     end
   end

data/lib/uniword/ooxml/schema/element_serializer.rb

@@ -301,12 +301,12 @@ module Uniword
         def get_attribute_value(element, attr_def)
           property_name = attr_def.property_name
 
-          # public_send is the canonical Ruby idiom for schema-driven
-          # serialization: reading attribute values by name from any
-          # Lutaml::Model::Serializable subclass. The property_name comes
-          # from the schema definition, not user input.
+          # Schema-driven read: the model's declared attributes are the
+          # allowlist, and the value is fetched through the model's
+          # public method table. The property_name comes from the schema
+          # definition, not user input.
           if element.is_a?(Lutaml::Model::Serializable) && element.class.attributes.key?(property_name)
-            element.public_send(property_name)
+            element.method(property_name).call
           elsif element.is_a?(Hash) && element.key?(property_name)
             element[property_name]
           end
@@ -320,9 +320,10 @@ module Uniword
         def get_child_elements(element, child_def)
           property_name = child_def.property_name
 
-          # Try to get children using property name
+          # Schema-driven read via the model's public method table,
+          # guarded by the declared attribute names.
           if element.is_a?(Lutaml::Model::Serializable) && element.class.attributes.key?(property_name)
-            element.public_send(property_name)
+            element.method(property_name).call
           elsif element.is_a?(Hash) && element.key?(property_name)
             element[property_name]
           end

data/lib/uniword/ooxml/types/hex_color_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      # ST_HexColor (ECMA-376): RGB hex color or "auto"
+      #
+      # Constrained string type: six hexadecimal digits (case-insensitive,
+      # ST_HexColorRGB) or the literal "auto" (ST_HexColorAuto). Invalid
+      # values raise Lutaml::Model::Type::InvalidValueError at cast time
+      # (attribute assignment and XML parsing).
+      class HexColorValue < Lutaml::Model::Type::String
+        # ST_HexColor value shape: "auto" or RRGGBB hex digits
+        HEX_COLOR_PATTERN = /\A(?:auto|[0-9A-Fa-f]{6})\z/
+
+        # Cast a value to a valid ST_HexColor string
+        #
+        # @param value [Object] the raw value
+        # @param options [Hash] cast options (unused)
+        # @return [String, nil] the validated color string
+        # @raise [Lutaml::Model::Type::InvalidValueError] when the value
+        #   is neither "auto" nor six hex digits
+        def self.cast(value, options = {})
+          casted = super
+          return casted if casted.nil? ||
+            Lutaml::Model::Utils.uninitialized?(casted)
+          return casted if HEX_COLOR_PATTERN.match?(casted)
+
+          raise Lutaml::Model::Type::InvalidValueError.new(
+            value, ["auto", "RRGGBB (6 hexadecimal digits)"]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types/ooxml_boolean.rb

@@ -5,29 +5,42 @@ require "lutaml/model"
 module Uniword
   module Ooxml
     module Types
-      # OOXML Boolean type for attributes
-      # OOXML uses "1"/"0" encoding for boolean attributes, not "true"/"false"
+      # OOXML Boolean type for attributes (ST_OnOff, ECMA-376)
+      # OOXML uses "1"/"0" encoding for boolean attributes; ST_OnOff also
+      # accepts the xsd:boolean spellings "true"/"false" and "on"/"off".
       #
-      # Parsing: "1" -> true, "0" -> false
+      # Parsing: "1"/"true"/"on" -> true, "0"/"false"/"off"/nil -> false
       # Serialization: true -> "1", false -> "0"
+      # Anything else raises Lutaml::Model::Type::InvalidValueError
+      # instead of passing through unchanged.
       class OoxmlBoolean < Lutaml::Model::Type::Boolean
+        # Accepted ST_OnOff spellings for Boolean true
+        TRUE_VALUES = [true, 1, "1", "true", "on"].freeze
+
+        # Accepted ST_OnOff spellings for Boolean false
+        FALSE_VALUES = [false, 0, "0", "false", "off"].freeze
+
+        # All accepted ST_OnOff spellings
+        ON_OFF_VALUES = (TRUE_VALUES + FALSE_VALUES).freeze
+
         def self.cast(value, _options = {})
-          case value
-          when true, "1", 1
-            true
-          when false, "0", 0, nil
-            false
-          else
-            value
-          end
+          return value if Lutaml::Model::Utils.uninitialized?(value)
+          return true if TRUE_VALUES.include?(value)
+          return false if FALSE_VALUES.include?(value) || value.nil?
+
+          raise Lutaml::Model::Type::InvalidValueError.new(
+            value, ON_OFF_VALUES
+          )
         end
 
         def self.serialize(value)
           return nil if value.nil?
-          return "1" if value == true || value.to_s.match?(/^(true|t|yes|y|1)$/i)
-          return "0" if value == false || value.to_s.match?(/^(false|f|no|n|0)$/i)
+          return "1" if TRUE_VALUES.include?(value)
+          return "0" if FALSE_VALUES.include?(value)
 
-          value
+          raise Lutaml::Model::Type::InvalidValueError.new(
+            value, ON_OFF_VALUES
+          )
         end
 
         # Override instance to_xml for OOXML boolean serialization