react-native-nitro-xlsx 0.2.5 → 0.2.7

package/thirdparty/OpenXLSX/cmake/recursive_library_type_test.cmake

@@ -0,0 +1,52 @@
+# Function: recursive_library_type_test
+# Purpose: test what library types a target is linking to, recurse into subtargets for INTERFACE_LIBRARY types
+# Parameters:
+#   TARGET_NAME     test this library target
+# Returns:
+#   ${TARGET_NAME}_HAS_STATIC   (PARENT_SCOPE): TRUE if at least one static library is linked
+#   ${TARGET_NAME}_HAS_SHARED   (PARENT_SCOPE): TRUE if at least one shared library is linked
+# Author:     Lars Uffmann (coding23@uffmann.name)
+function(recursive_library_type_test TARGET_NAME PREFIX)
+    set(_has_static FALSE)
+    set(_has_shared FALSE)
+
+    message( VERBOSE "      recursive_library_type_test:${PREFIX} TARGET ${TARGET_NAME}" )
+
+    get_target_property(_type ${TARGET_NAME} TYPE)
+    if("${_type}" STREQUAL "STATIC_LIBRARY")
+        set(_has_static TRUE)
+        message( DEBUG "      recursive_library_type_test:${PREFIX}   ${TARGET_NAME} is STATIC_LIBRARY" )
+    elseif("${_type}" STREQUAL "SHARED_LIBRARY")
+        set(_has_shared TRUE)
+        message( DEBUG "      recursive_library_type_test:${PREFIX}   ${TARGET_NAME} is SHARED_LIBRARY" )
+    elseif("${_type}" STREQUAL "INTERFACE_LIBRARY")
+        get_target_property(_links ${TARGET_NAME} INTERFACE_LINK_LIBRARIES)
+        message( DEBUG "      recursive_library_type_test:${PREFIX}   ${TARGET_NAME} is INTERFACE_LIBRARY, INTERFACE_LINK_LIBRARIES is ${_links}" )
+        foreach(_link IN LISTS _links)
+            if(TARGET ${_link})
+                recursive_library_type_test( ${_link} "  ${PREFIX}" ) # recurse
+                if(${_link}_HAS_STATIC)
+                    set(_has_static TRUE)
+                    message( DEBUG "      recursive_library_type_test:${PREFIX}   recursion found a static lib in ${_link}" )
+                endif()
+                if(${_link}_HAS_SHARED)
+                    set(_has_shared TRUE)
+                    message( DEBUG "      recursive_library_type_test:${PREFIX}   recursion found a shared lib in ${_link}" )
+                endif()
+                # message( DEBUG "   ${_link}_HAS_STATIC is ${${_link}_HAS_STATIC}, ${_link}_HAS_SHARED is ${${_link}_HAS_SHARED}" )
+            elseif(IS_ABSOLUTE "${_link}")
+                # _link is a path: check extension (.a/.lib => static; .so/.dylib/.dll => shared)
+                message( FATAL_ERROR "recursive_library_type_test:${PREFIX}   absolute: ${_link} - still need to address this" )
+            else()
+                # _link might be a linker name (-lfoo) or generator expression; handle below
+                message( FATAL_ERROR "recursive_library_type_test:${PREFIX}   linker name? ${_link} - still need to address this" )
+            endif()
+        endforeach()
+    else()
+    endif()
+
+    message( VERBOSE "      recursive_library_type_test:${PREFIX} TARGET ${TARGET_NAME} _has_static is ${_has_static}, _has_shared is ${_has_shared}" )
+    set(${TARGET_NAME}_HAS_STATIC ${_has_static} PARENT_SCOPE)
+    set(${TARGET_NAME}_HAS_SHARED ${_has_shared} PARENT_SCOPE)
+endfunction()
+# End of Function: recursive_library_type_test

package/thirdparty/OpenXLSX/gnu-make-crutch/OpenXLSX-Exports-shared.hpp

@@ -0,0 +1,42 @@
+
+#ifndef OPENXLSX_EXPORT_H
+#define OPENXLSX_EXPORT_H
+
+#ifdef OPENXLSX_STATIC_DEFINE
+#  define OPENXLSX_EXPORT
+#  define OPENXLSX_HIDDEN
+#else
+#  ifndef OPENXLSX_EXPORT
+#    ifdef OpenXLSX_EXPORTS
+        /* We are building this library */
+#      define OPENXLSX_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define OPENXLSX_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef OPENXLSX_HIDDEN
+#    define OPENXLSX_HIDDEN __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef OPENXLSX_DEPRECATED
+#  define OPENXLSX_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef OPENXLSX_DEPRECATED_EXPORT
+#  define OPENXLSX_DEPRECATED_EXPORT OPENXLSX_EXPORT OPENXLSX_DEPRECATED
+#endif
+
+#ifndef OPENXLSX_DEPRECATED_NO_EXPORT
+#  define OPENXLSX_DEPRECATED_NO_EXPORT OPENXLSX_HIDDEN OPENXLSX_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef OPENXLSX_NO_DEPRECATED
+#    define OPENXLSX_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* OPENXLSX_EXPORT_H */

package/thirdparty/OpenXLSX/gnu-make-crutch/OpenXLSX-Exports-static.hpp

@@ -0,0 +1,42 @@
+
+#ifndef OPENXLSX_EXPORT_H
+#define OPENXLSX_EXPORT_H
+
+#ifdef OPENXLSX_STATIC_DEFINE
+#  define OPENXLSX_EXPORT
+#  define OPENXLSX_HIDDEN
+#else
+#  ifndef OPENXLSX_EXPORT
+#    ifdef OpenXLSX_EXPORTS
+        /* We are building this library */
+#      define OPENXLSX_EXPORT 
+#    else
+        /* We are using this library */
+#      define OPENXLSX_EXPORT 
+#    endif
+#  endif
+
+#  ifndef OPENXLSX_HIDDEN
+#    define OPENXLSX_HIDDEN 
+#  endif
+#endif
+
+#ifndef OPENXLSX_DEPRECATED
+#  define OPENXLSX_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef OPENXLSX_DEPRECATED_EXPORT
+#  define OPENXLSX_DEPRECATED_EXPORT OPENXLSX_EXPORT OPENXLSX_DEPRECATED
+#endif
+
+#ifndef OPENXLSX_DEPRECATED_NO_EXPORT
+#  define OPENXLSX_DEPRECATED_NO_EXPORT OPENXLSX_HIDDEN OPENXLSX_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef OPENXLSX_NO_DEPRECATED
+#    define OPENXLSX_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* OPENXLSX_EXPORT_H */

package/thirdparty/OpenXLSX/vcpkg.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
+  "name": "openxlsx",
+  "version": "0.5.1",
+  "description": "OpenXLSX is a C++ library for reading, writing, creating and modifying Microsoft Excel® files, with the .xlsx format.",
+  "homepage": "https://github.com/troldal/OpenXLSX",
+  "license": "BSD-3-Clause",
+  "dependencies": [
+    {
+      "name": "boost-nowide",
+      "platform": "windows"
+    },
+    "miniz",
+    "pugixml",
+    {
+      "name": "vcpkg-cmake",
+      "host": true
+    },
+    {
+      "name": "vcpkg-cmake-config",
+      "host": true
+    }
+  ]
+}

package/thirdparty/README.md

@@ -0,0 +1,46 @@
+# Third-party sources
+
+These sources are **vendored** (committed) instead of being cloned at build
+time. Nothing here is downloaded during `pod install`, `npm install` or an
+Android CMake configure — the build simply compiles what is in this directory.
+
+| Directory | Upstream | Version / tag |
+|-----------|----------|---------------|
+| `OpenXLSX/` | https://github.com/troldal/OpenXLSX | `v0.5.1` |
+| `pugixml/` | https://github.com/zeux/pugixml | `v1.16` (OpenXLSX dependency) |
+| `miniz/` | https://github.com/richgel999/miniz | `3.1.2` (OpenXLSX dependency) |
+
+All upstream repositories are copied verbatim (`git archive` equivalent, no
+`.git`/`.github` metadata); only the files below are local additions:
+
+- `OpenXLSX/OpenXLSX/headers/OpenXLSX-Exports.hpp` — export macros, normally
+  generated by OpenXLSX's CMake install step.
+- `OpenXLSX/OpenXLSX/headers/OpenXLSX/**/*.hpp` — copies of the headers next to
+  them, so that `#include <OpenXLSX/XLWorkbook.hpp>` resolves with `headers/`
+  on the include path. These used to be a `OpenXLSX -> .` symlink, but **npm
+  does not ship symlink entries in a tarball**: the link vanished from the
+  published package and every `<OpenXLSX/...>` include failed to resolve in a
+  consumer project. Regenerate the copies with
+  `bash scripts/sync-openxlsx-headers.sh` after updating OpenXLSX.
+- `miniz/miniz_export.h` — export header, normally generated by miniz's CMake.
+
+## How the builds consume these
+
+- **CocoaPods** (`NitroXlsx.podspec`) compiles the C++ sources directly; the
+  header search paths point at `thirdparty/OpenXLSX`, `thirdparty/pugixml/src`
+  and `thirdparty/miniz`.
+- **Android** (`android/CMakeLists.txt`) runs `add_subdirectory(thirdparty/OpenXLSX)`.
+  OpenXLSX's own `manage_dependency()` would normally clone pugixml and miniz;
+  it is redirected to the vendored copies via
+  `FETCHCONTENT_SOURCE_DIR_PUGIXML_FETCH` / `FETCHCONTENT_SOURCE_DIR_MINIZ_FETCH`
+  (plus `FORCE_FETCH_ALL=ON`, which makes the lookup deterministic instead of
+  picking up a system-installed pugixml).
+- **C++ tests** (`cpp/tests/CMakeLists.txt`) use the same FetchContent
+  redirection, with `OPENXLSX_PATH` defaulting to `thirdparty/OpenXLSX`.
+
+## Updating a dependency
+
+1. Check out the new tag in a scratch directory.
+2. Replace the matching folder here, keeping the local additions listed above.
+3. Update the version in this README, in `NOTICE`, and re-run
+   `yarn test:cpp`.

package/thirdparty/miniz/.clang-format

@@ -0,0 +1,47 @@
+#
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+#
+AccessModifierOffset: -4
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: false
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit:     0
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+DerivePointerBinding: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 60
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerBindsToType: false
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: false
+Standard:        Cpp03
+IndentWidth:     4
+TabWidth:        4
+UseTab:          Never
+BreakBeforeBraces: Allman
+IndentFunctionDeclarationAfterType: false
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+SortIncludes: false

package/thirdparty/miniz/.travis.yml

@@ -0,0 +1,2 @@
+language: c
+script: bash amalgamate.sh

package/thirdparty/miniz/CMakeLists.txt

@@ -0,0 +1,333 @@
+cmake_minimum_required(VERSION 3.5)
+
+# determine whether this is a standalone project or included by other projects
+set (MINIZ_STANDALONE_PROJECT ON)
+if(DEFINED PROJECT_NAME)
+  set(MINIZ_STANDALONE_PROJECT OFF)
+endif()
+
+
+if(CMAKE_VERSION VERSION_LESS "3.12")
+  project(miniz C)
+  # see issue https://gitlab.kitware.com/cmake/cmake/merge_requests/1799
+else()
+  project(miniz C)
+  set(CMAKE_C_STANDARD 90)
+  set(CMAKE_VERBOSE_MAKEFILE ON)
+  # set(CMAKE_C_VISIBILITY_PRESET hidden)
+  # set(CMAKE_VISIBILITY_INLINES_HIDDEN YES)
+
+  if (MSVC)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /Zi /permissive-")
+  else ()
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wshadow -Wformat=2 -Wall -Wno-overlength-strings -pedantic")
+  endif ()
+endif()
+
+set(MINIZ_API_VERSION 3)
+set(MINIZ_MINOR_VERSION 1)
+set(MINIZ_PATCH_VERSION 2)
+set(MINIZ_VERSION
+    ${MINIZ_API_VERSION}.${MINIZ_MINOR_VERSION}.${MINIZ_PATCH_VERSION})
+
+if(CMAKE_BUILD_TYPE STREQUAL "")
+  # CMake defaults to leaving CMAKE_BUILD_TYPE empty. This screws up
+  # differentiation between debug and release builds.
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING
+    "Choose the type of build, options are: None (CMAKE_CXX_FLAGS or \
+CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." FORCE)
+endif ()
+
+option(BUILD_EXAMPLES "Build examples" ${MINIZ_STANDALONE_PROJECT})
+option(BUILD_FUZZERS "Build fuzz targets" OFF)
+option(AMALGAMATE_SOURCES "Amalgamate sources into miniz.h/c" OFF)
+option(BUILD_HEADER_ONLY "Build a header-only version" OFF)
+option(BUILD_SHARED_LIBS "Build shared library instead of static" OFF)
+option(BUILD_NO_STDIO" Build a without stdio version" OFF)
+option(BUILD_TESTS "Build tests" ${MINIZ_STANDALONE_PROJECT})
+option(INSTALL_PROJECT "Install project" ${MINIZ_STANDALONE_PROJECT})
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+
+if(INSTALL_PROJECT)
+  include(GNUInstallDirs)
+endif()
+
+if(BUILD_HEADER_ONLY)
+  set(AMALGAMATE_SOURCES ON CACHE BOOL "Build a header-only version" FORCE)
+endif(BUILD_HEADER_ONLY)
+
+if(AMALGAMATE_SOURCES)
+  # Amalgamate
+  file(COPY miniz.h DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/)
+  file(READ miniz.h MINIZ_H)
+  file(READ miniz_common.h MINIZ_COMMON_H)
+  file(READ miniz_tdef.h MINIZ_TDEF_H)
+  file(READ miniz_tinfl.h MINIZ_TINFL_H)
+  file(READ miniz_zip.h MINIZ_ZIP_H)
+  file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h
+     "${MINIZ_COMMON_H} ${MINIZ_TDEF_H} ${MINIZ_TINFL_H} ${MINIZ_ZIP_H}")
+
+  file(COPY miniz.c DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/)
+  file(READ miniz_tdef.c MINIZ_TDEF_C)
+  file(READ miniz_tinfl.c MINIZ_TINFL_C)
+  file(READ miniz_zip.c MINIZ_ZIP_C)
+  file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.c
+     "${MINIZ_TDEF_C} ${MINIZ_TINFL_C} ${MINIZ_ZIP_C}")
+
+  file(READ ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h AMAL_MINIZ_H)
+  file(READ ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.c AMAL_MINIZ_C)
+  foreach(REPLACE_STRING miniz;miniz_common;miniz_tdef;miniz_tinfl;miniz_zip;miniz_export)
+    string(REPLACE "#include \"${REPLACE_STRING}.h\"" "" AMAL_MINIZ_H "${AMAL_MINIZ_H}")
+    string(REPLACE "#include \"${REPLACE_STRING}.h\"" "" AMAL_MINIZ_C "${AMAL_MINIZ_C}")
+  endforeach()
+  string(CONCAT AMAL_MINIZ_H "#ifndef MINIZ_EXPORT\n#define MINIZ_EXPORT\n#endif\n" "${AMAL_MINIZ_H}")
+  if(BUILD_HEADER_ONLY)
+    string(CONCAT AMAL_MINIZ_H "${AMAL_MINIZ_H}" "\n#ifndef MINIZ_HEADER_FILE_ONLY\n"
+             "${AMAL_MINIZ_C}" "\n#endif // MINIZ_HEADER_FILE_ONLY\n")
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h "${AMAL_MINIZ_H}")
+    add_library(${PROJECT_NAME} INTERFACE)
+
+    # Might not be a good idea to force this on the library user
+    # as it could bloat the global namespace
+    # https://github.com/libevent/libevent/issues/460
+    # target_compile_definitions(${PROJECT_NAME}
+    #     INTERFACE $<$<C_COMPILER_ID:GNU>:_GNU_SOURCE>)
+
+    set_property(TARGET ${PROJECT_NAME} APPEND
+      PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/amalgamation>
+      $<INSTALL_INTERFACE:include>
+    )
+  else(BUILD_HEADER_ONLY)
+    string(CONCAT AMAL_MINIZ_C "#include \"miniz.h\"\n" "${AMAL_MINIZ_C}")
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h "${AMAL_MINIZ_H}")
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.c "${AMAL_MINIZ_C}")
+    set(miniz_SOURCE ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h
+                     ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.c)
+    add_library(${PROJECT_NAME} STATIC ${miniz_SOURCE})
+    target_include_directories(${PROJECT_NAME} PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/amalgamation>
+      $<INSTALL_INTERFACE:include>
+    )
+  endif(BUILD_HEADER_ONLY)
+
+  set(INSTALL_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/miniz.h)
+
+  file(GLOB_RECURSE ZIP_FILES RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/amalgamation" "${CMAKE_CURRENT_BINARY_DIR}/amalgamation/*")
+  file(GLOB_RECURSE ZIP_FILES2 RELATIVE "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/examples/*")
+  list(APPEND ZIP_FILES ${ZIP_FILES2})
+  list(APPEND ZIP_FILES "ChangeLog.md")
+  list(APPEND ZIP_FILES "readme.md")
+  list(APPEND ZIP_FILES "LICENSE")
+  set(ZIP_OUT_FN "${CMAKE_CURRENT_BINARY_DIR}/miniz-${MINIZ_VERSION}.zip")
+  message(STATUS "Zip files: ${ZIP_FILES}")
+  add_custom_command(
+		COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/examples ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/examples
+		COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/ChangeLog.md ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/ChangeLog.md
+		COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/readme.md ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/readme.md
+		COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/LICENSE ${CMAKE_CURRENT_BINARY_DIR}/amalgamation/LICENSE
+		COMMAND ${CMAKE_COMMAND} -E tar "cf" "${ZIP_OUT_FN}" --format=zip -- ${ZIP_FILES}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/amalgamation"
+        OUTPUT  "${ZIP_OUT_FN}"
+        DEPENDS ${ZIP_FILES}
+        COMMENT "Zipping to ${CMAKE_CURRENT_BINARY_DIR}/miniz.zip."
+    )
+
+	add_custom_target(
+	  create_zip ALL
+	  DEPENDS "${ZIP_OUT_FN}"
+	)
+else(AMALGAMATE_SOURCES)
+  include(GenerateExportHeader)
+  set(miniz_SOURCE miniz.c miniz_zip.c miniz_tinfl.c miniz_tdef.c)
+  add_library(${PROJECT_NAME} ${miniz_SOURCE})
+  generate_export_header(${PROJECT_NAME})
+
+  if(NOT BUILD_SHARED_LIBS)
+    string(TOUPPER ${PROJECT_NAME} PROJECT_UPPER)
+    set_target_properties(${PROJECT_NAME}
+        PROPERTIES INTERFACE_COMPILE_DEFINITIONS ${PROJECT_UPPER}_STATIC_DEFINE)
+  else()
+    set_property(TARGET ${PROJECT_NAME} PROPERTY C_VISIBILITY_PRESET hidden)
+  endif()
+
+  set_property(TARGET ${PROJECT_NAME} PROPERTY VERSION ${MINIZ_VERSION})
+  set_property(TARGET ${PROJECT_NAME} PROPERTY SOVERSION ${MINIZ_API_VERSION})
+
+  target_include_directories(${PROJECT_NAME} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+    $<INSTALL_INTERFACE:include>
+  )
+
+  file(GLOB INSTALL_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.h)
+  list(APPEND
+       INSTALL_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}_export.h)
+endif(AMALGAMATE_SOURCES)
+
+if(NOT BUILD_HEADER_ONLY)
+  target_compile_definitions(${PROJECT_NAME}
+    PRIVATE $<$<C_COMPILER_ID:GNU>:_GNU_SOURCE>)
+
+  # pkg-config file
+  configure_file(miniz.pc.in ${CMAKE_CURRENT_BINARY_DIR}/miniz.pc @ONLY)
+
+  if(INSTALL_PROJECT)
+    install(FILES
+      ${CMAKE_CURRENT_BINARY_DIR}/miniz.pc
+      DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+  endif()
+endif()
+
+if(BUILD_NO_STDIO)
+  target_compile_definitions(${PROJECT_NAME} PRIVATE MINIZ_NO_STDIO)
+endif()
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY
+  INTERFACE_${PROJECT_NAME}_MAJOR_VERSION ${MINIZ_API_VERSION})
+set_property(TARGET ${PROJECT_NAME} APPEND PROPERTY
+  COMPATIBLE_INTERFACE_STRING ${PROJECT_NAME}_MAJOR_VERSION
+)
+
+if(INSTALL_PROJECT)
+  install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}Targets
+    RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR}
+    ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    # users can use <miniz.h> or <miniz/miniz.h>
+    INCLUDES DESTINATION include ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
+  )
+
+  include(CMakePackageConfigHelpers)
+  write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
+    VERSION ${MINIZ_VERSION}
+    COMPATIBILITY AnyNewerVersion
+  )
+
+  export(EXPORT ${PROJECT_NAME}Targets
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Targets.cmake"
+    NAMESPACE ${PROJECT_NAME}::
+  )
+  configure_file(Config.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake"
+    @ONLY
+  )
+
+  set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+  install(EXPORT ${PROJECT_NAME}Targets
+    FILE
+      ${PROJECT_NAME}Targets.cmake
+    NAMESPACE
+      ${PROJECT_NAME}::
+    DESTINATION
+      ${ConfigPackageLocation}
+  )
+  install(
+    FILES
+      "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake"
+      "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
+    DESTINATION
+      ${ConfigPackageLocation}
+    COMPONENT
+      Devel
+  )
+endif()
+
+if(BUILD_EXAMPLES)
+  set(EXAMPLE1_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example1.c")
+  set(EXAMPLE2_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example2.c")
+  set(EXAMPLE3_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example3.c")
+  set(EXAMPLE4_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example4.c")
+  set(EXAMPLE5_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example5.c")
+  set(EXAMPLE6_SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/examples/example6.c")
+  set(MINIZ_TESTER_SRC_LIST
+      "${CMAKE_CURRENT_SOURCE_DIR}/tests/miniz_tester.cpp"
+      "${CMAKE_CURRENT_SOURCE_DIR}/tests/timer.cpp")
+
+  add_executable(example1 ${EXAMPLE1_SRC_LIST})
+  target_link_libraries(example1 miniz)
+  if(NOT BUILD_NO_STDIO)
+    add_executable(example2 ${EXAMPLE2_SRC_LIST})
+    target_link_libraries(example2 miniz)
+  endif()
+  add_executable(example3 ${EXAMPLE3_SRC_LIST})
+  target_link_libraries(example3 miniz)
+  add_executable(example4 ${EXAMPLE4_SRC_LIST})
+  target_link_libraries(example4 miniz)
+  add_executable(example5 ${EXAMPLE5_SRC_LIST})
+  target_link_libraries(example5 miniz)
+  add_executable(example6 ${EXAMPLE6_SRC_LIST})
+  target_link_libraries(example6 miniz)
+  if(${UNIX})
+      target_link_libraries(example6 m)
+  endif()
+
+  # add_executable(miniz_tester ${MINIZ_TESTER_SRC_LIST})
+  # target_link_libraries(miniz_tester miniz)
+endif(BUILD_EXAMPLES)
+
+if(BUILD_FUZZERS)
+  set(FUZZ_MAIN_SRC "${CMAKE_CURRENT_SOURCE_DIR}/tests/fuzz_main.c")
+
+  set(CHECKSUM_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/checksum_fuzzer.c")
+  set(FLUSH_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/flush_fuzzer.c")
+  set(UNCOMPRESS_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/uncompress_fuzzer.c")
+  set(UNCOMPRESS2_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/uncompress2_fuzzer.c")
+  set(COMPRESS_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/compress_fuzzer.c")
+  set(SMALL_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/small_fuzzer.c")
+  set(LARGE_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/large_fuzzer.c")
+  set(ZIP_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/zip_fuzzer.c")
+  set(ADD_IN_PLACE_FUZZER_SRC_LIST "${FUZZ_MAIN_SRC}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/add_in_place_fuzzer.c")
+
+  add_executable(checksum_fuzzer ${CHECKSUM_FUZZER_SRC_LIST})
+  target_link_libraries(checksum_fuzzer miniz)
+
+  add_executable(flush_fuzzer ${FLUSH_FUZZER_SRC_LIST})
+  target_link_libraries(flush_fuzzer miniz)
+
+  add_executable(uncompress_fuzzer ${UNCOMPRESS_FUZZER_SRC_LIST})
+  target_link_libraries(uncompress_fuzzer miniz)
+
+  add_executable(uncompress2_fuzzer ${UNCOMPRESS2_FUZZER_SRC_LIST})
+  target_link_libraries(uncompress2_fuzzer miniz)
+
+  add_executable(compress_fuzzer ${COMPRESS_FUZZER_SRC_LIST})
+  target_link_libraries(compress_fuzzer miniz)
+
+  add_executable(small_fuzzer ${SMALL_FUZZER_SRC_LIST})
+  target_link_libraries(small_fuzzer miniz)
+
+  add_executable(large_fuzzer ${LARGE_FUZZER_SRC_LIST})
+  target_link_libraries(large_fuzzer miniz)
+
+  add_executable(zip_fuzzer ${ZIP_FUZZER_SRC_LIST})
+  target_link_libraries(zip_fuzzer miniz)
+
+  add_executable(add_in_place_fuzzer ${ADD_IN_PLACE_FUZZER_SRC_LIST})
+  target_link_libraries(add_in_place_fuzzer miniz)
+endif()
+
+if(BUILD_TESTS)
+  enable_language(CXX)
+  set(CMAKE_CXX_STANDARD 20)
+  set(CMAKE_CXX_STANDARD_REQUIRED YES)
+
+  add_executable(catch_tests tests/main.cpp tests/catch_amalgamated.cpp)
+  if(BUILD_NO_STDIO)
+    target_compile_definitions(catch_tests PRIVATE -DMINIZ_NO_STDIO)
+  endif()
+  target_link_libraries(catch_tests miniz)
+
+  enable_testing()
+
+  add_test(NAME catch_tests COMMAND $<TARGET_FILE:catch_tests>)
+endif()
+
+set(INCLUDE_INSTALL_DIR "include")
+
+if(INSTALL_PROJECT)
+  install(FILES ${INSTALL_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
+endif()
+

package/thirdparty/miniz/CMakePresets.json

@@ -0,0 +1,31 @@
+{
+  "version": 6,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 5,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "gcc",
+      "displayName": "GCC",
+      "description": "Default build options for GCC",
+      "generator": "Unix Makefiles",
+      "binaryDir": "${sourceDir}/build"
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "gcc",
+      "configurePreset": "gcc"
+    }
+  ],
+  "testPresets": [
+    {
+      "name": "gcc",
+      "configurePreset": "gcc",
+      "output": {"outputOnFailure": true},
+      "execution": {"noTestsAction": "error", "stopOnFailure": true}
+    }
+  ]
+}